Add new parameter. If value is nonzero consider TMPDIR environment
[kopensolaris-gnu/glibc.git] / sysdeps / posix / tempname.c
index b8eccbb..1a11375 100644 (file)
-/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
+/* Copyright (C) 1991,92,93,94,95,96,97,98 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
 
-The GNU C Library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public License as
-published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version.
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
 
-The GNU C Library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-Library General Public License for more details.
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
 
-You should have received a copy of the GNU Library General Public
-License along with the GNU C Library; see the file COPYING.LIB.  If
-not, write to the Free Software Foundation, Inc., 675 Mass Ave,
-Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
-#include <ansidecl.h>
-#include <errno.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <sys/time.h>
 
 /* Return nonzero if DIR is an existent directory.  */
 static int
-DEFUN(diraccess, (dir), CONST char *dir)
+direxists (const char *dir)
 {
   struct stat buf;
-  return __stat (dir, &buf) == 0 && S_ISDIR (buf.st_mode);
+  return __xstat (_STAT_VER, dir, &buf) == 0 && S_ISDIR (buf.st_mode);
 }
 
-/* Return nonzero if FILE exists.  */
-static int
-DEFUN(exists, (file), CONST char *file)
+/* Path search algorithm, for tmpnam, tmpfile, etc.  If DIR is
+   non-null and exists, uses it; otherwise uses the first of $TMPDIR,
+   P_tmpdir, /tmp that exists.  Copies into TMPL a template suitable
+   for use with mk[s]temp.  Will fail (-1) if DIR is non-null and
+   doesn't exist, none of the searched dirs exists, or there's not
+   enough space in TMPL. */
+int
+__path_search (char *tmpl, size_t tmpl_len, const char *dir, const char *pfx,
+              int try_tmpdir)
 {
-  /* We can stat the file even if we can't read its data.  */
-  struct stat st;
-  int save = errno;
-  if (__stat (file, &st) == 0)
-    return 1;
+  const char *d;
+  size_t dlen, plen;
+
+  if (!pfx || !pfx[0])
+    {
+      pfx = "file";
+      plen = 4;
+    }
   else
     {
-      /* We report that the file exists if stat failed for a reason other
-        than nonexistence.  In this case, it may or may not exist, and we
-        don't know; but reporting that it does exist will never cause any
-        trouble, while reporting that it doesn't exist when it does would
-        violate the interface of __stdio_gen_tempname.  */
-      int exists = errno != ENOENT;
-      errno = save;
-      return exists;
+      plen = strlen (pfx);
+      if (plen > 5)
+       plen = 5;
     }
-}
-
 
-/* These are the characters used in temporary filenames.  */
-static CONST char letters[] =
-  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-
-/* Generate a temporary filename and return it (in a static buffer).  If
-   STREAMPTR is not NULL, open a stream "w+b" on the file and set
-   *STREAMPTR to it.  If DIR_SEARCH is nonzero, DIR and PFX are used as
-   described for tempnam.  If not, a temporary filename in P_tmpdir with no
-   special prefix is generated.  If LENPTR is not NULL, *LENPTR is set the
-   to length (including the terminating '\0') of the resultant filename,
-   which is returned.  This goes through a cyclic pattern of all possible
-   filenames consisting of five decimal digits of the current pid and three
-   of the characters in `letters'.  Data for tempnam and tmpnam is kept
-   separate, but when tempnam is using P_tmpdir and no prefix (i.e, it is
-   identical to tmpnam), the same data is used.  Each potential filename is
-   tested for an already-existing file of the same name, and no name of an
-   existing file will be returned.  When the cycle reaches its end
-   (12345ZZZ), NULL is returned.  */
-char *
-DEFUN(__stdio_gen_tempname, (dir, pfx, dir_search, lenptr, streamptr),
-      CONST char *dir AND CONST char *pfx AND
-      int dir_search AND size_t *lenptr AND
-      FILE **streamptr)
-{
-  int saverrno = errno;
-  static CONST char tmpdir[] = P_tmpdir;
-  static size_t indices[2];
-  size_t *idx;
-  static char buf[FILENAME_MAX];
-  static pid_t oldpid = (pid_t) 0;
-  pid_t pid = __getpid();
-  register size_t len, plen, dlen;
-
-  if (dir_search)
+  if (try_tmpdir)
     {
-      register CONST char *d = getenv("TMPDIR");
-      if (d != NULL && !diraccess(d))
-       d = NULL;
-      if (d == NULL && dir != NULL && diraccess(dir))
-       d = dir;
-      if (d == NULL && diraccess(tmpdir))
-       d = tmpdir;
-      if (d == NULL && diraccess("/tmp"))
-       d = "/tmp";
-      if (d == NULL)
-       {
-         errno = ENOENT;
-         return NULL;
-       }
-      dir = d;
+      d = __secure_getenv ("TMPDIR");
+      if (d != NULL && direxists (d))
+       dir = d;
+      else if (dir != NULL && direxists (dir))
+       /* nothing */ ;
     }
+  if (direxists (P_tmpdir))
+    dir = P_tmpdir;
+  else if (strcmp (P_tmpdir, "/tmp") != 0 && direxists ("/tmp"))
+    dir = "/tmp";
   else
-    dir = tmpdir;
+    {
+      __set_errno (ENOENT);
+      return -1;
+    }
 
   dlen = strlen (dir);
-
-  /* Remove trailing slashes from the directory name.  */
   while (dlen > 1 && dir[dlen - 1] == '/')
-    --dlen;
+    dlen--;                    /* remove trailing slashes */
 
-  if (pfx != NULL && *pfx != '\0')
+  /* check we have room for "${dir}/${pfx}XXXXXX\0" */
+  if (tmpl_len < dlen + 1 + plen + 6 + 1)
     {
-      plen = strlen(pfx);
-      if (plen > 5)
-       plen = 5;
+      __set_errno (EINVAL);
+      return -1;
     }
-  else
-    plen = 0;
 
-  if (dir != tmpdir && !strcmp(dir, tmpdir))
-    dir = tmpdir;
-  idx = &indices[(plen == 0 && dir == tmpdir) ? 1 : 0];
+  sprintf (tmpl, "%*s/%*sXXXXXX", dlen, dir, plen, pfx);
+  return 0;
+}
 
-  if (pid != oldpid)
+/* These are the characters used in temporary filenames.  */
+static const char letters[] =
+"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+
+/* Generate a temporary file name based on TMPL.  TMPL must match the
+   rules for mk[s]temp (i.e. end in "XXXXXX").  The name constructed
+   does not exist at the time of the call to __gen_tempname.  TMPL is
+   overwritten with the result.  If OPENIT is nonzero, creates the
+   file and returns a read-write fd; the file is mode 0600 modulo
+   umask.  If LARGEFILE is nonzero, uses open64() instead of open().
+
+   We use a clever algorithm to get hard-to-predict names. */
+int
+__gen_tempname (char *tmpl, int openit, int largefile)
+{
+  int len;
+  char *XXXXXX;
+  static uint64_t value;
+  struct timeval tv;
+  int count, fd;
+  int save_errno = errno;
+
+  len = strlen (tmpl);
+  if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
     {
-      oldpid = pid;
-      indices[0] = indices[1] = 0;
+      __set_errno (EINVAL);
+      return -1;
     }
 
-  len = dlen + 1 + plen + 5 + 3;
-  for (; *idx < ((sizeof (letters) - 1) * (sizeof (letters) - 1) *
-                (sizeof (letters) - 1));
-       ++*idx)
+  /* This is where the Xs start.  */
+  XXXXXX = &tmpl[len - 6];
+
+  /* Get some more or less random data.  */
+  __gettimeofday (&tv, NULL);
+  value += ((uint64_t) tv.tv_usec << 16) ^ tv.tv_sec ^ __getpid ();
+
+  for (count = 0; count < TMP_MAX; value += 7777, ++count)
     {
-      /* Construct a file name and see if it already exists.
-
-        We use a single counter in *IDX to cycle each of three
-        character positions through each of 62 possible letters.  */
-
-      if (sizeof (buf) < len ||
-         sprintf (buf, "%.*s/%.*s%.5d%c%c%c",
-                  (int) dlen, dir, (int) plen,
-                  pfx, pid % 100000,
-                  letters[*idx
-                          % (sizeof (letters) - 1)],
-                  letters[(*idx / (sizeof (letters) - 1))
-                          % (sizeof (letters) - 1)],
-                  letters[(*idx / ((sizeof (letters) - 1) *
-                                   (sizeof (letters) - 1)))
-                          % (sizeof (letters) - 1)]
-                  ) != (int) len)
-       return NULL;
-
-      if (streamptr != NULL)
+      uint64_t v = value;
+
+      /* Fill in the random bits.  */
+      XXXXXX[0] = letters[v % 62];
+      v /= 62;
+      XXXXXX[1] = letters[v % 62];
+      v /= 62;
+      XXXXXX[2] = letters[v % 62];
+      v /= 62;
+      XXXXXX[3] = letters[v % 62];
+      v /= 62;
+      XXXXXX[4] = letters[v % 62];
+      v /= 62;
+      XXXXXX[5] = letters[v % 62];
+
+      if (openit)
        {
-         /* Try to create the file atomically.  */
-         int fd = __open (buf, O_RDWR|O_CREAT|O_EXCL, 0666);
+         fd = (largefile
+               ? __open (tmpl, O_RDWR | O_CREAT | O_EXCL, 0666)
+               : __open64 (tmpl, O_RDWR | O_CREAT | O_EXCL, 0666));
          if (fd >= 0)
            {
-             /* We got a new file that did not previously exist.
-                Create a stream for it.  */
-             *streamptr = __newstream ();
-             if (*streamptr == NULL)
+             __set_errno (save_errno);
+             return fd;
+           }
+         else if (errno != EEXIST)
+           /* Any other error will apply also to other names we might
+              try, and there are 2^32 or so of them, so give up now. */
+           return -1;
+       }
+      else
+       {
+         struct stat st;
+         if (__xstat (_STAT_VER, tmpl, &st) < 0)
+           {
+             if (errno == ENOENT)
                {
-                 /* We lost trying to create a stream (out of memory?).
-                    Nothing to do but remove the file, close the descriptor,
-                    and return failure.  */
-                 const int save = errno;
-                 (void) remove (buf);
-                 (void) __close (fd);
-                 errno = save;
-                 return NULL;
+                 __set_errno (save_errno);
+                 return 0;
                }
-             (*streamptr)->__cookie = (PTR) fd;
-             (*streamptr)->__mode.__write = 1;
-             (*streamptr)->__mode.__read = 1;
-             (*streamptr)->__mode.__binary = 1;
+             else
+               /* Give up now. */
+               return -1;
            }
-         else
-           continue;
        }
-      else if (exists (buf))
-       continue;
-
-      /* If the file already existed we have continued the loop above,
-        so we only get here when we have a winning name to return.  */
-
-      errno = saverrno;
-
-      if (lenptr != NULL)
-       *lenptr = len + 1;
-      return buf;
     }
 
   /* We got out of the loop because we ran out of combinations to try.  */
-  errno = EEXIST;              /* ? */
-  return NULL;
+  __set_errno (EEXIST);
+  return -1;
 }