src/mktemp.c

   1 /* Create a temporary file or directory, safely.
   2    Copyright (C) 2007-2022 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Jim Meyering and Eric Blake.  */
  18
  19 #include <config.h>
  20 #include <sys/types.h>
  21 #include <getopt.h>
  22
  23 #include "system.h"
  24
  25 #include "close-stream.h"
  26 #include "die.h"
  27 #include "error.h"
  28 #include "filenamecat.h"
  29 #include "quote.h"
  30 #include "tempname.h"
  31
  32 /* The official name of this program (e.g., no 'g' prefix).  */
  33 #define PROGRAM_NAME "mktemp"
  34
  35 #define AUTHORS \
  36   proper_name ("Jim Meyering"), \
  37   proper_name ("Eric Blake")
  38
  39 static char const *default_template = "tmp.XXXXXXXXXX";
  40
  41 /* For long options that have no equivalent short option, use a
  42    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
  43 enum
  44 {
  45   SUFFIX_OPTION = CHAR_MAX + 1,
  46 };
  47
  48 static struct option const longopts[] =
  49 {
  50   {"directory", no_argument, NULL, 'd'},
  51   {"quiet", no_argument, NULL, 'q'},
  52   {"dry-run", no_argument, NULL, 'u'},
  53   {"suffix", required_argument, NULL, SUFFIX_OPTION},
  54   {"tmpdir", optional_argument, NULL, 'p'},
  55   {GETOPT_HELP_OPTION_DECL},
  56   {GETOPT_VERSION_OPTION_DECL},
  57   {NULL, 0, NULL, 0}
  58 };
  59
  60 void
  61 usage (int status)
  62 {
  63   if (status != EXIT_SUCCESS)
  64     emit_try_help ();
  65   else
  66     {
  67       printf (_("Usage: %s [OPTION]... [TEMPLATE]\n"), program_name);
  68       fputs (_("\
  69 Create a temporary file or directory, safely, and print its name.\n\
  70 TEMPLATE must contain at least 3 consecutive 'X's in last component.\n\
  71 If TEMPLATE is not specified, use tmp.XXXXXXXXXX, and --tmpdir is implied.\n\
  72 "), stdout);
  73       fputs (_("\
  74 Files are created u+rw, and directories u+rwx, minus umask restrictions.\n\
  75 "), stdout);
  76       fputs ("\n", stdout);
  77       fputs (_("\
  78   -d, --directory     create a directory, not a file\n\
  79   -u, --dry-run       do not create anything; merely print a name (unsafe)\n\
  80   -q, --quiet         suppress diagnostics about file/dir-creation failure\n\
  81 "), stdout);
  82       fputs (_("\
  83       --suffix=SUFF   append SUFF to TEMPLATE; SUFF must not contain a slash.\n\
  84                         This option is implied if TEMPLATE does not end in X\n\
  85 "), stdout);
  86       fputs (_("\
  87   -p DIR, --tmpdir[=DIR]  interpret TEMPLATE relative to DIR; if DIR is not\n\
  88                         specified, use $TMPDIR if set, else /tmp.  With\n\
  89                         this option, TEMPLATE must not be an absolute name;\n\
  90                         unlike with -t, TEMPLATE may contain slashes, but\n\
  91                         mktemp creates only the final component\n\
  92 "), stdout);
  93       fputs (_("\
  94   -t                  interpret TEMPLATE as a single file name component,\n\
  95                         relative to a directory: $TMPDIR, if set; else the\n\
  96                         directory specified via -p; else /tmp [deprecated]\n\
  97 "), stdout);
  98       fputs (HELP_OPTION_DESCRIPTION, stdout);
  99       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 100       emit_ancillary_info (PROGRAM_NAME);
 101     }
 102
 103   exit (status);
 104 }
 105
 106 static size_t
 107 count_consecutive_X_s (char const *s, size_t len)
 108 {
 109   size_t n = 0;
 110   for ( ; len && s[len - 1] == 'X'; len--)
 111     ++n;
 112   return n;
 113 }
 114
 115 static int
 116 mkstemp_len (char *tmpl, size_t suff_len, size_t x_len, bool dry_run)
 117 {
 118   return gen_tempname_len (tmpl, suff_len, 0, dry_run ? GT_NOCREATE : GT_FILE,
 119                            x_len);
 120 }
 121
 122 static int
 123 mkdtemp_len (char *tmpl, size_t suff_len, size_t x_len, bool dry_run)
 124 {
 125   return gen_tempname_len (tmpl, suff_len, 0, dry_run ? GT_NOCREATE : GT_DIR,
 126                            x_len);
 127 }
 128
 129 /* True if we have already closed standard output.  */
 130 static bool stdout_closed;
 131
 132 /* Avoid closing stdout twice.  Since we conditionally call
 133    close_stream (stdout) in order to decide whether to clean up a
 134    temporary file, the exit hook needs to know whether to do all of
 135    close_stdout or just the stderr half.  */
 136 static void
 137 maybe_close_stdout (void)
 138 {
 139   if (!stdout_closed)
 140     close_stdout ();
 141   else if (close_stream (stderr) != 0)
 142     _exit (EXIT_FAILURE);
 143 }
 144
 145 int
 146 main (int argc, char **argv)
 147 {
 148   char const *dest_dir;
 149   char const *dest_dir_arg = NULL;
 150   bool suppress_file_err = false;
 151   int c;
 152   unsigned int n_args;
 153   char *template;
 154   char *suffix = NULL;
 155   bool use_dest_dir = false;
 156   bool deprecated_t_option = false;
 157   bool create_directory = false;
 158   bool dry_run = false;
 159   int status = EXIT_SUCCESS;
 160   size_t x_count;
 161   size_t suffix_len;
 162   char *dest_name;
 163
 164   initialize_main (&argc, &argv);
 165   set_program_name (argv[0]);
 166   setlocale (LC_ALL, "");
 167   bindtextdomain (PACKAGE, LOCALEDIR);
 168   textdomain (PACKAGE);
 169
 170   atexit (maybe_close_stdout);
 171
 172   while ((c = getopt_long (argc, argv, "dp:qtuV", longopts, NULL)) != -1)
 173     {
 174       switch (c)
 175         {
 176         case 'd':
 177           create_directory = true;
 178           break;
 179         case 'p':
 180           dest_dir_arg = optarg;
 181           use_dest_dir = true;
 182           break;
 183         case 'q':
 184           suppress_file_err = true;
 185           break;
 186         case 't':
 187           use_dest_dir = true;
 188           deprecated_t_option = true;
 189           break;
 190         case 'u':
 191           dry_run = true;
 192           break;
 193
 194         case SUFFIX_OPTION:
 195           suffix = optarg;
 196           break;
 197
 198         case_GETOPT_HELP_CHAR;
 199
 200         case 'V': /* Undocumented alias, for compatibility with the original
 201                      mktemp program.  */
 202         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 203         default:
 204           usage (EXIT_FAILURE);
 205         }
 206     }
 207
 208   n_args = argc - optind;
 209   if (2 <= n_args)
 210     {
 211       error (0, 0, _("too many templates"));
 212       usage (EXIT_FAILURE);
 213     }
 214
 215   if (n_args == 0)
 216     {
 217       use_dest_dir = true;
 218       template = (char *) default_template;
 219     }
 220   else
 221     {
 222       template = argv[optind];
 223     }
 224
 225   if (suffix)
 226     {
 227       size_t len = strlen (template);
 228       if (!len || template[len - 1] != 'X')
 229         {
 230           die (EXIT_FAILURE, 0,
 231                _("with --suffix, template %s must end in X"),
 232                quote (template));
 233         }
 234       suffix_len = strlen (suffix);
 235       dest_name = xcharalloc (len + suffix_len + 1);
 236       memcpy (dest_name, template, len);
 237       memcpy (dest_name + len, suffix, suffix_len + 1);
 238       template = dest_name;
 239       suffix = dest_name + len;
 240     }
 241   else
 242     {
 243       template = xstrdup (template);
 244       suffix = strrchr (template, 'X');
 245       if (!suffix)
 246         suffix = strchr (template, '\0');
 247       else
 248         suffix++;
 249       suffix_len = strlen (suffix);
 250     }
 251
 252   /* At this point, template is malloc'd, and suffix points into template.  */
 253   if (suffix_len && last_component (suffix) != suffix)
 254     {
 255       die (EXIT_FAILURE, 0,
 256            _("invalid suffix %s, contains directory separator"),
 257            quote (suffix));
 258     }
 259   x_count = count_consecutive_X_s (template, suffix - template);
 260   if (x_count < 3)
 261     die (EXIT_FAILURE, 0, _("too few X's in template %s"), quote (template));
 262
 263   if (use_dest_dir)
 264     {
 265       if (deprecated_t_option)
 266         {
 267           char *env = getenv ("TMPDIR");
 268           if (env && *env)
 269             dest_dir = env;
 270           else if (dest_dir_arg && *dest_dir_arg)
 271             dest_dir = dest_dir_arg;
 272           else
 273             dest_dir = "/tmp";
 274
 275           if (last_component (template) != template)
 276             die (EXIT_FAILURE, 0,
 277                  _("invalid template, %s, contains directory separator"),
 278                  quote (template));
 279         }
 280       else
 281         {
 282           if (dest_dir_arg && *dest_dir_arg)
 283             dest_dir = dest_dir_arg;
 284           else
 285             {
 286               char *env = getenv ("TMPDIR");
 287               dest_dir = (env && *env ? env : "/tmp");
 288             }
 289           if (IS_ABSOLUTE_FILE_NAME (template))
 290             die (EXIT_FAILURE, 0,
 291                  _("invalid template, %s; with --tmpdir,"
 292                    " it may not be absolute"),
 293                  quote (template));
 294         }
 295
 296       dest_name = file_name_concat (dest_dir, template, NULL);
 297       free (template);
 298       template = dest_name;
 299       /* Note that suffix is now invalid.  */
 300     }
 301
 302   /* Make a copy to be used in case of diagnostic, since failing
 303      mkstemp may leave the buffer in an undefined state.  */
 304   dest_name = xstrdup (template);
 305
 306   if (create_directory)
 307     {
 308       int err = mkdtemp_len (dest_name, suffix_len, x_count, dry_run);
 309       if (err != 0)
 310         {
 311           if (!suppress_file_err)
 312             error (0, errno, _("failed to create directory via template %s"),
 313                    quote (template));
 314           status = EXIT_FAILURE;
 315         }
 316     }
 317   else
 318     {
 319       int fd = mkstemp_len (dest_name, suffix_len, x_count, dry_run);
 320       if (fd < 0 || (!dry_run && close (fd) != 0))
 321         {
 322           if (!suppress_file_err)
 323             error (0, errno, _("failed to create file via template %s"),
 324                    quote (template));
 325           status = EXIT_FAILURE;
 326         }
 327     }
 328
 329   if (status == EXIT_SUCCESS)
 330     {
 331       puts (dest_name);
 332       /* If we created a file, but then failed to output the file
 333          name, we should clean up the mess before failing.  */
 334       if (!dry_run && ((stdout_closed = true), close_stream (stdout) != 0))
 335         {
 336           int saved_errno = errno;
 337           remove (dest_name);
 338           if (!suppress_file_err)
 339             error (0, saved_errno, _("write error"));
 340           status = EXIT_FAILURE;
 341         }
 342     }
 343
 344 #ifdef lint
 345   free (dest_name);
 346   free (template);
 347 #endif
 348
 349   return status;
 350 }