gl/lib/tempname.c

   1 /* tempname.c - generate the name of a temporary file.
   2
   3    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4    2000, 2001, 2002, 2003, 2005, 2006, 2007, 2009 Free Software Foundation,
   5    Inc.
   6
   7    This program is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* Extracted from glibc sysdeps/posix/tempname.c.  See also tmpdir.c.  */
  21
  22 #if !_LIBC
  23 # include <config.h>
  24 # include "tempname.h"
  25 # include "randint.h"
  26 #endif
  27
  28 #include <sys/types.h>
  29 #include <assert.h>
  30
  31 #include <errno.h>
  32 #ifndef __set_errno
  33 # define __set_errno(Val) errno = (Val)
  34 #endif
  35
  36 #include <stdio.h>
  37 #ifndef P_tmpdir
  38 # define P_tmpdir "/tmp"
  39 #endif
  40 #ifndef TMP_MAX
  41 # define TMP_MAX 238328
  42 #endif
  43 #ifndef __GT_FILE
  44 # define __GT_FILE      0
  45 # define __GT_BIGFILE   1
  46 # define __GT_DIR       2
  47 # define __GT_NOCREATE  3
  48 #endif
  49
  50 #include <stdbool.h>
  51 #include <stddef.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54
  55 #include <fcntl.h>
  56 #include <sys/time.h>
  57 #include <stdint.h>
  58 #include <unistd.h>
  59
  60 #include <sys/stat.h>
  61
  62 #if _LIBC
  63 # define struct_stat64 struct stat64
  64 # define small_open __open
  65 # define large_open __open64
  66 #else
  67 # define struct_stat64 struct stat
  68 # define small_open open
  69 # define large_open open
  70 # define __gen_tempname gen_tempname
  71 # define __getpid getpid
  72 # define __gettimeofday gettimeofday
  73 # define __mkdir mkdir
  74 # define __lxstat64(version, file, buf) lstat (file, buf)
  75 # define __xstat64(version, file, buf) stat (file, buf)
  76 #endif
  77
  78 #if ! (HAVE___SECURE_GETENV || _LIBC)
  79 # define __secure_getenv getenv
  80 #endif
  81
  82 #if _LIBC
  83 /* Return nonzero if DIR is an existent directory.  */
  84 static int
  85 direxists (const char *dir)
  86 {
  87   struct_stat64 buf;
  88   return __xstat64 (_STAT_VER, dir, &buf) == 0 && S_ISDIR (buf.st_mode);
  89 }
  90
  91 /* Path search algorithm, for tmpnam, tmpfile, etc.  If DIR is
  92    non-null and exists, uses it; otherwise uses the first of $TMPDIR,
  93    P_tmpdir, /tmp that exists.  Copies into TMPL a template suitable
  94    for use with mk[s]temp.  Will fail (-1) if DIR is non-null and
  95    doesn't exist, none of the searched dirs exists, or there's not
  96    enough space in TMPL. */
  97 int
  98 __path_search (char *tmpl, size_t tmpl_len, const char *dir, const char *pfx,
  99                int try_tmpdir)
 100 {
 101   const char *d;
 102   size_t dlen, plen;
 103
 104   if (!pfx || !pfx[0])
 105     {
 106       pfx = "file";
 107       plen = 4;
 108     }
 109   else
 110     {
 111       plen = strlen (pfx);
 112       if (plen > 5)
 113         plen = 5;
 114     }
 115
 116   if (try_tmpdir)
 117     {
 118       d = __secure_getenv ("TMPDIR");
 119       if (d != NULL && direxists (d))
 120         dir = d;
 121       else if (dir != NULL && direxists (dir))
 122         /* nothing */ ;
 123       else
 124         dir = NULL;
 125     }
 126   if (dir == NULL)
 127     {
 128       if (direxists (P_tmpdir))
 129         dir = P_tmpdir;
 130       else if (strcmp (P_tmpdir, "/tmp") != 0 && direxists ("/tmp"))
 131         dir = "/tmp";
 132       else
 133         {
 134           __set_errno (ENOENT);
 135           return -1;
 136         }
 137     }
 138
 139   dlen = strlen (dir);
 140   while (dlen > 1 && dir[dlen - 1] == '/')
 141     dlen--;                     /* remove trailing slashes */
 142
 143   /* check we have room for "${dir}/${pfx}XXXXXX\0" */
 144   if (tmpl_len < dlen + 1 + plen + 6 + 1)
 145     {
 146       __set_errno (EINVAL);
 147       return -1;
 148     }
 149
 150   sprintf (tmpl, "%.*s/%.*sXXXXXX", (int) dlen, dir, (int) plen, pfx);
 151   return 0;
 152 }
 153 #endif /* _LIBC */
 154
 155 static inline bool
 156 check_x_suffix (char const *s, size_t len)
 157 {
 158   return strspn (s, "X") == len;
 159 }
 160
 161 /* These are the characters used in temporary file names.  */
 162 static const char letters[] =
 163 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 164
 165 /* Generate a temporary file name based on TMPL.  TMPL must end in a
 166    a sequence of at least X_SUFFIX_LEN "X"s.  The name constructed
 167    does not exist at the time of the call to __gen_tempname.  TMPL is
 168    overwritten with the result.
 169
 170    KIND may be one of:
 171    __GT_NOCREATE:       simply verify that the name does not exist
 172                         at the time of the call.
 173    __GT_FILE:           create the file using open(O_CREAT|O_EXCL)
 174                         and return a read-write fd.  The file is mode 0600.
 175    __GT_BIGFILE:        same as __GT_FILE but use open64().
 176    __GT_DIR:            create a directory, which will be mode 0700.
 177
 178    We use a clever algorithm to get hard-to-predict names. */
 179 int
 180 gen_tempname_len (char *tmpl, int kind, size_t x_suffix_len)
 181 {
 182   size_t len;
 183   char *XXXXXX;
 184   unsigned int count;
 185   int fd = -1;
 186   int save_errno = errno;
 187   struct_stat64 st;
 188   struct randint_source *rand_src;
 189
 190   /* A lower bound on the number of temporary files to attempt to
 191      generate.  The maximum total number of temporary file names that
 192      can exist for a given template is 62**6.  It should never be
 193      necessary to try all these combinations.  Instead if a reasonable
 194      number of names is tried (we define reasonable as 62**3) fail to
 195      give the system administrator the chance to remove the problems.  */
 196 #define ATTEMPTS_MIN (62 * 62 * 62)
 197
 198   /* The number of times to attempt to generate a temporary file.  To
 199      conform to POSIX, this must be no smaller than TMP_MAX.  */
 200 #if ATTEMPTS_MIN < TMP_MAX
 201   unsigned int attempts = TMP_MAX;
 202 #else
 203   unsigned int attempts = ATTEMPTS_MIN;
 204 #endif
 205
 206   len = strlen (tmpl);
 207   if (len < x_suffix_len || ! check_x_suffix (&tmpl[len - x_suffix_len],
 208                                               x_suffix_len))
 209     {
 210       __set_errno (EINVAL);
 211       return -1;
 212     }
 213
 214   rand_src = randint_all_new (NULL, 8);
 215   if (! rand_src)
 216     return -1;
 217
 218   /* This is where the Xs start.  */
 219   XXXXXX = &tmpl[len - x_suffix_len];
 220
 221   for (count = 0; count < attempts; ++count)
 222     {
 223       size_t i;
 224
 225       for (i = 0; i < x_suffix_len; i++)
 226         {
 227           XXXXXX[i] = letters[randint_genmax (rand_src, sizeof letters - 2)];
 228         }
 229
 230       switch (kind)
 231         {
 232         case __GT_FILE:
 233           fd = small_open (tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
 234           break;
 235
 236         case __GT_BIGFILE:
 237           fd = large_open (tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
 238           break;
 239
 240         case __GT_DIR:
 241           fd = __mkdir (tmpl, S_IRUSR | S_IWUSR | S_IXUSR);
 242           break;
 243
 244         case __GT_NOCREATE:
 245           /* This case is backward from the other three.  This function
 246              succeeds if __xstat fails because the name does not exist.
 247              Note the continue to bypass the common logic at the bottom
 248              of the loop.  */
 249           if (__lxstat64 (_STAT_VER, tmpl, &st) < 0)
 250             {
 251               if (errno == ENOENT)
 252                 {
 253                   __set_errno (save_errno);
 254                   fd = 0;
 255                   goto done;
 256                 }
 257               else
 258                 {
 259                   /* Give up now. */
 260                   fd = -1;
 261                   goto done;
 262                 }
 263             }
 264           continue;
 265
 266         default:
 267           assert (! "invalid KIND in __gen_tempname");
 268         }
 269
 270       if (fd >= 0)
 271         {
 272           __set_errno (save_errno);
 273           goto done;
 274         }
 275       else if (errno != EEXIST)
 276         {
 277           fd = -1;
 278           goto done;
 279         }
 280     }
 281
 282   randint_all_free (rand_src);
 283
 284   /* We got out of the loop because we ran out of combinations to try.  */
 285   __set_errno (EEXIST);
 286   return -1;
 287
 288  done:
 289   {
 290     int saved_errno = errno;
 291     randint_all_free (rand_src);
 292     __set_errno (saved_errno);
 293   }
 294   return fd;
 295 }
 296
 297 int
 298 __gen_tempname (char *tmpl, int kind)
 299 {
 300   return gen_tempname_len (tmpl, kind, 6);
 301 }