glibc/sysdeps/posix/tempname.c
1996-10-02 01:40:17 +00:00

277 lines
7.6 KiB
C

/* Copyright (C) 1991, 92, 93, 94, 95, 96 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 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. */
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#ifdef USE_IN_LIBIO
# include "libioP.h"
# include <libio.h>
#endif
/* Return nonzero if DIR is an existent directory. */
static int
diraccess (const char *dir)
{
struct stat buf;
return __stat (dir, &buf) == 0 && S_ISDIR (buf.st_mode);
}
/* Return nonzero if FILE exists. */
static int
exists (const char *file)
{
/* 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;
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;
__set_errno (save);
return exists;
}
}
/* 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 *
__stdio_gen_tempname (char *buf, size_t bufsize, const char *dir,
const char *pfx, int dir_search, size_t *lenptr,
FILE **streamptr)
{
int saverrno = errno;
static const char tmpdir[] = P_tmpdir;
static size_t indices[2];
size_t *idx;
#if 0
static pid_t oldpid = (pid_t) 0;
#endif
pid_t pid = __getpid();
register size_t len, plen, dlen;
int wrapped;
if (dir_search)
{
register const char *d = __secure_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)
{
__set_errno (ENOENT);
return NULL;
}
dir = d;
}
else
dir = tmpdir;
dlen = strlen (dir);
/* Remove trailing slashes from the directory name. */
while (dlen > 1 && dir[dlen - 1] == '/')
--dlen;
if (pfx != NULL && *pfx != '\0')
{
plen = strlen (pfx);
if (plen > 5)
plen = 5;
}
else
plen = 0;
if (dir != tmpdir && !strcmp (dir, tmpdir))
dir = tmpdir;
idx = &indices[(plen == 0 && dir == tmpdir) ? 1 : 0];
#if 0
/* XXX Is this ever useful??? At least when using a thread package
which uses different PIDs for the threads it is not helpful. */
if (pid != oldpid)
{
oldpid = pid;
indices[0] = indices[1] = 0;
}
#endif
wrapped = 0; /* We have not yet wrapped around the index counter. */
len = dlen + 1 + plen + 5 + 3;
while (1)
{
size_t i;
if (*idx >= ((sizeof (letters) - 1) * (sizeof (letters) - 1) *
(sizeof (letters) - 1)))
{
if (wrapped)
/* We really wrapped around this call. Can't believe it
but nevertheless stop the endless loop. */
break;
indices[0] = indices[1] = 0;
wrapped = 1;
}
i = (*idx)++;
/* 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 (__snprintf (buf, bufsize, "%.*s/%.*s%.5d%c%c%c",
(int) dlen, dir, (int) plen,
pfx, pid % 100000,
letters[i % (sizeof (letters) - 1)],
letters[(i / (sizeof (letters) - 1))
% (sizeof (letters) - 1)],
letters[(i / ((sizeof (letters) - 1) *
(sizeof (letters) - 1)))
% (sizeof (letters) - 1)]
) != (int) len)
return NULL;
if (streamptr != NULL)
{
/* Try to create the file atomically. */
int fd = __open (buf, 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. */
#ifdef USE_IN_LIBIO
int save;
struct locked_FILE
{
struct _IO_FILE_plus fp;
#ifdef _IO_MTSAFE_IO
_IO_lock_t lock;
#endif
} *new_f;
struct _IO_FILE_plus *fp;
new_f = (struct locked_FILE *)
malloc (sizeof (struct locked_FILE));
if (new_f == NULL)
{
/* We lost trying to create a stream (out of memory?).
Nothing to do but remove the file, close the descriptor,
and return failure. */
save = errno;
lose:
(void) remove (buf);
(void) __close (fd);
__set_errno (save);
return NULL;
}
fp = &new_f->fp;
#ifdef _IO_MTSAFE_IO
fp->file._lock = &new_f->lock;
#endif
_IO_init (&fp->file, 0);
_IO_JUMPS (&fp->file) = &_IO_file_jumps;
_IO_file_init (&fp->file);
# if !_IO_UNIFIED_JUMPTABLES
fp->vtable = NULL;
# endif
if (_IO_file_attach (&fp->file, fd) == NULL)
{
save = errno;
free (fp);
goto lose;
}
fp->file._flags &= ~_IO_DELETE_DONT_CLOSE;
*streamptr = (FILE *) fp;
#else
*streamptr = __newstream ();
if (*streamptr == NULL)
{
/* 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);
__set_errno (save);
return NULL;
}
(*streamptr)->__cookie = (__ptr_t) (long int) fd;
(*streamptr)->__mode.__write = 1;
(*streamptr)->__mode.__read = 1;
(*streamptr)->__mode.__binary = 1;
#endif
}
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. */
__set_errno (saverrno);
if (lenptr != NULL)
*lenptr = len + 1;
return buf;
}
/* We got out of the loop because we ran out of combinations to try. */
__set_errno (EEXIST); /* ? */
return NULL;
}