src/mktemp.c

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