s/DOTLOCK/dotlock_t/.
[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
29 #include "g13.h"
30
31 #include <gcrypt.h>
32
33 #include "i18n.h"
34 #include "sysutils.h"
35 #include "gc-opt-flags.h"
36
37
38 enum cmd_and_opt_values {
39   aNull = 0,
40   oQuiet        = 'q',
41   oVerbose      = 'v',
42
43   aGPGConfList  = 500,
44   aGPGConfTest,
45   aCreate,
46   aMount,
47   aUmount,
48
49   oOptions,
50   oDebug,
51   oDebugLevel,
52   oDebugAll,
53   oDebugNone,
54   oDebugWait,
55   oDebugAllowCoreDump,
56   oLogFile,
57   oNoLogFile,
58   oAuditLog,
59
60   oOutput,
61
62   oAgentProgram,
63   oDisplay,
64   oTTYname,
65   oTTYtype,
66   oLCctype,
67   oLCmessages,
68   oXauthority,
69
70   oStatusFD,
71   oLoggerFD,
72
73   oNoVerbose,
74   oNoSecmemWarn,
75   oNoGreeting,
76   oNoTTY,
77   oNoOptions,
78   oHomedir,
79   oWithColons,
80   oDryRun,
81
82   oRecipient,
83
84   oNoRandomSeedFile,
85   oFakedSystemTime
86  };
87
88
89 static ARGPARSE_OPTS opts[] = {
90
91   ARGPARSE_group (300, N_("@Commands:\n ")),
92
93   ARGPARSE_c (aCreate, "create", N_("Create a new file system container")),
94   ARGPARSE_c (aMount,  "mount",  N_("Mount a file system container") ),
95   ARGPARSE_c (aUmount, "umount", N_("Unmount a file system container") ),
96
97   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
98   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
99
100   ARGPARSE_group (301, N_("@\nOptions:\n ")),
101
102   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
103
104   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
105   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
106   ARGPARSE_s_n (oQuiet, "quiet",  N_("be somewhat more quiet")),
107   ARGPARSE_s_n (oNoTTY, "no-tty", N_("don't use the terminal at all")),
108   ARGPARSE_s_s (oLogFile, "log-file",  N_("|FILE|write log output to FILE")),
109   ARGPARSE_s_n (oNoLogFile, "no-log-file", "@"),
110   ARGPARSE_s_i (oLoggerFD, "logger-fd", "@"),
111
112   ARGPARSE_s_s (oAuditLog, "audit-log",
113                 N_("|FILE|write an audit log to FILE")),
114   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
115
116   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
117
118   ARGPARSE_p_u (oDebug, "debug", "@"),
119   ARGPARSE_s_s (oDebugLevel, "debug-level",
120                 N_("|LEVEL|set the debugging level to LEVEL")),
121   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
122   ARGPARSE_s_n (oDebugNone, "debug-none", "@"),
123   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
124   ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
125
126   ARGPARSE_s_i (oStatusFD, "status-fd",
127                 N_("|FD|write status info to this FD")),
128
129   ARGPARSE_group (302, N_(
130   "@\n(See the man page for a complete listing of all commands and options)\n"
131   )),
132
133   ARGPARSE_group (303, N_("@\nExamples:\n\n"
134     " blurb\n"
135                           " blurb\n")),
136
137   /* Hidden options. */
138   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
139   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"), 
140   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
141   ARGPARSE_s_n (oNoOptions, "no-options", "@"),
142   ARGPARSE_s_s (oHomedir, "homedir", "@"),   
143   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
144   ARGPARSE_s_s (oDisplay,    "display", "@"),
145   ARGPARSE_s_s (oTTYname,    "ttyname", "@"),
146   ARGPARSE_s_s (oTTYtype,    "ttytype", "@"),
147   ARGPARSE_s_s (oLCctype,    "lc-ctype", "@"),
148   ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
149   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
150   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
151   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
152   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
153
154   /* Command aliases.  */
155
156   ARGPARSE_end ()
157 };
158
159
160 /* Global variable to keep an error count. */
161 int g13_errors_seen = 0;
162
163 /* It is possible that we are currently running under setuid permissions.  */
164 static int maybe_setuid = 1;
165
166 /* Helper to implement --debug-level and --debug.  */
167 static const char *debug_level;
168 static unsigned int debug_value;
169
170 static void set_cmd (enum cmd_and_opt_values *ret_cmd,
171                      enum cmd_and_opt_values new_cmd );
172
173 static void emergency_cleanup (void);
174
175
176 static const char *
177 my_strusage( int level )
178 {
179   const char *p;
180
181   switch (level)
182     {
183     case 11: p = "g13 (GnuPG)";
184       break;
185     case 13: p = VERSION; break;
186     case 17: p = PRINTABLE_OS_NAME; break;
187     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
188       break;
189     case 1:
190     case 40: p = _("Usage: g13 [options] [files] (-h for help)");
191       break;
192     case 41:
193       p = _("Syntax: g13 [options] [files]\n"
194             "Create, mount or unmount an encrypted file system container\n");
195       break;
196
197     case 31: p = "\nHome: "; break;
198     case 32: p = opt.homedir; break;
199      
200     default: p = NULL; break;
201     }
202   return p;
203 }
204
205
206 static void
207 wrong_args (const char *text)
208 {
209   fputs (_("usage: g13 [options] "), stderr);
210   fputs (text, stderr);
211   putc ('\n', stderr);
212   g13_exit (2);
213 }
214
215
216 /* Setup the debugging.  With a DEBUG_LEVEL of NULL only the active
217    debug flags are propagated to the subsystems.  With DEBUG_LEVEL
218    set, a specific set of debug flags is set; and individual debugging
219    flags will be added on top.  */
220 static void
221 set_debug (void)
222 {
223   if (!debug_level)
224     ;
225   else if (!strcmp (debug_level, "none"))
226     opt.debug = 0;
227   else if (!strcmp (debug_level, "basic"))
228     opt.debug = DBG_ASSUAN_VALUE|DBG_MOUNT_VALUE;
229   else if (!strcmp (debug_level, "advanced"))
230     opt.debug = DBG_ASSUAN_VALUE|DBG_MOUNT_VALUE;
231   else if (!strcmp (debug_level, "expert"))
232     opt.debug = (DBG_ASSUAN_VALUE|DBG_MOUNT_VALUE|DBG_CRYPTO_VALUE);
233   else if (!strcmp (debug_level, "guru"))
234     opt.debug = ~0;
235   else
236     {
237       log_error (_("invalid debug-level `%s' given\n"), debug_level);
238       g13_exit(2);
239     }
240
241   opt.debug |= debug_value;
242
243   if (opt.debug && !opt.verbose)
244     opt.verbose = 1;
245   if (opt.debug)
246     opt.quiet = 0;
247
248   if (opt.debug & DBG_CRYPTO_VALUE )
249     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
250   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
251 }
252  
253
254
255 static void
256 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
257 {
258   enum cmd_and_opt_values cmd = *ret_cmd;
259
260   if (!cmd || cmd == new_cmd)
261     cmd = new_cmd;
262   else 
263     {
264       log_error (_("conflicting commands\n"));
265       g13_exit (2);
266     }
267
268   *ret_cmd = cmd;
269 }
270
271
272 /* Helper to add recipients to a list. */
273 static int
274 add_encryption_key (ctrl_t ctrl, const char *name,
275                     void /*FIXME*/ *keylist, int is_cms)
276 {
277   /* FIXME: Decide whether to add a CMS or OpenPGP key and then add
278      the key to a list.  */
279   /* int rc = foo_add_to_certlist (ctrl, name, 0, recplist, is_encrypt_to); */
280   /* if (rc) */
281   /*   { */
282   /*     if (recp_required) */
283   /*       { */
284   /*         log_error ("can't encrypt to `%s': %s\n", name, gpg_strerror (rc)); */
285   /*         gpgsm_status2 (ctrl, STATUS_INV_RECP, */
286   /*                        get_inv_recpsgnr_code (rc), name, NULL); */
287   /*       } */
288   /*     else */
289   /*       log_info (_("NOTE: won't be able to encrypt to `%s': %s\n"), */
290   /*                 name, gpg_strerror (rc)); */
291   /*   } */
292   return 0; /* Key is good.  */
293 }
294
295
296 int
297 main ( int argc, char **argv)
298 {
299   ARGPARSE_ARGS pargs;
300   int orig_argc;
301   char **orig_argv;
302   const char *fname;
303   int may_coredump;
304   FILE *configfp = NULL;
305   char *configname = NULL;
306   unsigned configlineno;
307   int parse_debug = 0;
308   int no_more_options = 0;
309   int default_config =1;
310   char *logfile = NULL;
311   char *auditlog = NULL;
312   int greeting = 0;
313   int nogreeting = 0;
314   int debug_wait = 0;
315   int use_random_seed = 1;
316   int nokeysetup = 0;
317   enum cmd_and_opt_values cmd = 0;
318   struct server_control_s ctrl;
319   estream_t auditfp = NULL;
320   strlist_t recipients = NULL;
321
322   /*mtrace();*/
323
324   gnupg_reopen_std ("g13");
325   set_strusage (my_strusage);
326   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
327   gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
328
329   log_set_prefix ("g13", 1);
330
331   /* Make sure that our subsystems are ready.  */
332   i18n_init();
333   init_common_subsystems ();
334
335   /* Check that the Libgcrypt is suitable.  */
336   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
337     log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt", 
338                NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
339
340   /* Take extra care of the random pool.  */
341   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
342
343   may_coredump = disable_core_dumps ();
344   
345   gnupg_init_signals (0, emergency_cleanup);
346   
347   create_dotlock (NULL); /* Register locking cleanup.  */
348
349   opt.homedir = default_homedir ();
350
351   /* First check whether we have a config file on the commandline.  */
352   orig_argc = argc;
353   orig_argv = argv;
354   pargs.argc = &argc;
355   pargs.argv = &argv;
356   pargs.flags= 1|(1<<6);  /* Do not remove the args, ignore version.  */
357   while (arg_parse( &pargs, opts))
358     {
359       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
360         parse_debug++;
361       else if (pargs.r_opt == oOptions)
362         { /* Yes, there is one, so we do not try the default one but
363              read the config file when it is encountered at the
364              commandline.  */
365           default_config = 0;
366         }
367       else if (pargs.r_opt == oNoOptions)
368         default_config = 0; /* --no-options */
369       else if (pargs.r_opt == oHomedir)
370         opt.homedir = pargs.r.ret_str;
371     }
372
373   /* Initialize the secure memory. */
374   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
375   maybe_setuid = 0;
376
377   /* 
378      Now we are now working under our real uid 
379   */
380
381
382   /* Setup a default control structure for command line mode.  */
383   memset (&ctrl, 0, sizeof ctrl);
384   g13_init_default_ctrl (&ctrl);
385
386   /* Set the default option file */
387   if (default_config )
388     configname = make_filename (opt.homedir, "g13.conf", NULL);
389   
390   argc        = orig_argc;
391   argv        = orig_argv;
392   pargs.argc  = &argc;
393   pargs.argv  = &argv;
394   pargs.flags =  1;  /* Do not remove the args.  */
395
396  next_pass:
397   if (configname) {
398     configlineno = 0;
399     configfp = fopen (configname, "r");
400     if (!configfp)
401       {
402         if (default_config)
403           {
404             if (parse_debug)
405               log_info (_("NOTE: no default option file `%s'\n"), configname);
406           }
407         else 
408           {
409             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
410             g13_exit(2);
411           }
412         xfree (configname);
413         configname = NULL;
414       }
415     if (parse_debug && configname)
416       log_info (_("reading options from `%s'\n"), configname);
417     default_config = 0;
418   }
419
420   while (!no_more_options 
421          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
422     {
423       switch (pargs.r_opt)
424         {
425         case aGPGConfList: 
426         case aGPGConfTest: 
427           set_cmd (&cmd, pargs.r_opt);
428           nogreeting = 1;
429           nokeysetup = 1;
430           break;
431
432         case aMount:
433         case aUmount:
434           nokeysetup = 1;
435         case aCreate:
436           set_cmd (&cmd, pargs.r_opt);
437           break;
438
439         case oOutput: opt.outfile = pargs.r.ret_str; break;
440
441         case oQuiet: opt.quiet = 1; break;
442         case oNoGreeting: nogreeting = 1; break;
443         case oNoTTY:  break;
444
445         case oDryRun: opt.dry_run = 1; break;
446
447         case oVerbose:
448           opt.verbose++;
449           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
450           break;
451         case oNoVerbose:
452           opt.verbose = 0;
453           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
454           break;
455
456         case oLogFile: logfile = pargs.r.ret_str; break;
457         case oNoLogFile: logfile = NULL; break;          
458
459         case oAuditLog: auditlog = pargs.r.ret_str; break;
460
461         case oDebug: debug_value |= pargs.r.ret_ulong; break;
462         case oDebugAll: debug_value = ~0; break;
463         case oDebugNone: debug_value = 0; break;
464         case oDebugLevel: debug_level = pargs.r.ret_str; break;
465         case oDebugWait: debug_wait = pargs.r.ret_int; break;
466         case oDebugAllowCoreDump:
467           may_coredump = enable_core_dumps ();
468           break;
469
470         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
471         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
472
473         case oNoOptions: break; /* no-options */
474         case oOptions:
475           /* Config files may not be nested (silently ignore them).  */
476           if (!configfp)
477             {
478               xfree(configname);
479               configname = xstrdup (pargs.r.ret_str);
480               goto next_pass;
481             }
482           break;
483
484         case oHomedir: opt.homedir = pargs.r.ret_str; break;
485
486         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
487         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
488         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
489         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
490         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
491         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
492         case oXauthority: opt.xauthority = xstrdup (pargs.r.ret_str); break;
493           
494         case oFakedSystemTime:
495           {
496             time_t faked_time = isotime2epoch (pargs.r.ret_str); 
497             if (faked_time == (time_t)(-1))
498               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
499             gnupg_set_time (faked_time, 0);
500           }
501           break;
502
503         case oNoSecmemWarn: gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); break;
504
505         case oNoRandomSeedFile: use_random_seed = 0; break;
506
507         case oRecipient: /* Store the encryption key.  */
508           add_to_strlist (&recipients, pargs.r.ret_str);
509           break;
510
511
512         default: 
513           pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR; 
514           break;
515         }
516     }
517
518   if (configfp)
519     {
520       fclose (configfp);
521       configfp = NULL;
522       /* Keep a copy of the config filename. */
523       opt.config_filename = configname;
524       configname = NULL;
525       goto next_pass;
526     }
527   xfree (configname);
528   configname = NULL;
529
530   if (!opt.config_filename)
531     opt.config_filename = make_filename (opt.homedir, "g13.conf", NULL);
532
533   if (log_get_errorcount(0))
534     g13_exit(2);
535
536   /* Now that we have the options parsed we need to update the default
537      control structure.  */
538   g13_init_default_ctrl (&ctrl);
539
540   if (nogreeting)
541     greeting = 0;
542   
543   if (greeting)
544     {
545       fprintf(stderr, "%s %s; %s\n",
546               strusage(11), strusage(13), strusage(14) );
547       fprintf(stderr, "%s\n", strusage(15) );
548     }
549
550   if (may_coredump && !opt.quiet)
551     log_info (_("WARNING: program may create a core file!\n"));
552
553   if (logfile)
554     {
555       log_set_file (logfile);
556       log_set_prefix (NULL, 1|2|4);
557     }
558
559   if (gnupg_faked_time_p ())
560     {
561       gnupg_isotime_t tbuf;
562
563       log_info (_("WARNING: running with faked system time: "));
564       gnupg_get_isotime (tbuf);
565       dump_isotime (tbuf);
566       log_printf ("\n");
567     }
568
569   /* Print any pending secure memory warnings.  */
570   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
571
572   /* Setup the debug flags for all subsystems.  */
573   set_debug ();
574
575   /* Install a regular exit handler to make real sure that the secure
576      memory gets wiped out.  */
577   if (atexit (emergency_cleanup))
578     {
579       log_error ("atexit failed\n");
580       g13_exit (2);
581     }
582
583   /* Terminate if we found any error until now.  */
584   if (log_get_errorcount(0))
585     g13_exit (2);
586   
587   /* Set the standard GnuPG random seed file.  */
588   if (use_random_seed) 
589     {
590       char *p = make_filename (opt.homedir, "random_seed", NULL);
591       gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
592       xfree(p);
593     }
594   
595   /* Store given filename into FNAME. */
596   fname = argc? *argv : NULL;
597
598   /* Parse all given encryption keys.  This does a lookup of the keys
599      and stops if any of the given keys was not found. */
600   if (!nokeysetup)
601     {
602       strlist_t sl;
603       int failed = 0;
604       
605       for (sl = recipients; sl; sl = sl->next)
606         if (add_encryption_key (&ctrl, sl->d, NULL /* FIXME*/, 0))
607           failed = 1;
608       if (failed)
609         g13_exit (1);
610     }
611   
612   /* Dispatch command.  */
613   switch (cmd)
614     {
615     case aGPGConfList: 
616       { /* List options and default values in the GPG Conf format.  */
617         char *config_filename_esc = percent_escape (opt.config_filename, NULL);
618
619         printf ("gpgconf-g13.conf:%lu:\"%s\n",
620                 GC_OPT_FLAG_DEFAULT, config_filename_esc);
621         xfree (config_filename_esc);
622
623         printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
624         printf ("quiet:%lu:\n", GC_OPT_FLAG_NONE);
625         printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
626         printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
627       }
628       break;
629     case aGPGConfTest:
630       /* This is merely a dummy command to test whether the
631          configuration file is valid.  */
632       break;
633
634     case aCreate: /* Create a new container. */
635       {
636         if (argc != 1) 
637           wrong_args ("--create filename");
638         
639       }
640       break;
641
642     default:
643         log_error (_("invalid command (there is no implicit command)\n"));
644         break;
645     }
646
647   /* Print the audit result if needed.  */
648   if (auditlog && auditfp)
649     {
650       audit_print_result (ctrl.audit, auditfp, 0);
651       audit_release (ctrl.audit);
652       ctrl.audit = NULL;
653       es_fclose (auditfp);
654     }
655   
656   /* Cleanup.  */
657   g13_exit (0);
658   return 8; /*NOTREACHED*/
659 }
660
661 /* Note: This function is used by signal handlers!. */
662 static void
663 emergency_cleanup (void)
664 {
665   gcry_control (GCRYCTL_TERM_SECMEM );
666 }
667
668
669 void
670 g13_exit (int rc)
671 {
672   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
673   if (opt.debug & DBG_MEMSTAT_VALUE)
674     {
675       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
676       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
677     }
678   if (opt.debug)
679     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
680   emergency_cleanup ();
681   rc = rc? rc : log_get_errorcount(0)? 2 : g13_errors_seen? 1 : 0;
682   exit (rc);
683 }
684
685
686 void
687 g13_init_default_ctrl (struct server_control_s *ctrl)
688 {
689   (void)ctrl;
690 }
691
692