[bison.git] / lib / tempname.c

/* Copyright (C) 1991-1999, 2000, 2001 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#if HAVE_CONFIG_H
# include <config.h>
#endif

#include <sys/types.h>
#include <assert.h>

#include <errno.h>
#ifndef __set_errno
# define __set_errno(Val) errno = (Val)
#endif

#include <stdio.h>
#ifndef P_tmpdir
# define P_tmpdir "/tmp"
#endif
#ifndef TMP_MAX
# define TMP_MAX 238328
#endif
#ifndef __GT_FILE
# define __GT_FILE	0
# define __GT_BIGFILE	1
# define __GT_DIR	2
# define __GT_NOCREATE	3
#endif

#if STDC_HEADERS || _LIBC
# include <stddef.h>
# include <string.h>
#endif

#include <stdlib.h>

#if HAVE_FCNTL_H || _LIBC
# include <fcntl.h>
#endif

#if HAVE_SYS_TIME_H || _LIBC
# include <sys/time.h>
#endif

#if HAVE_STDINT_H || _LIBC
# include <stdint.h>
#endif

#if HAVE_UNISTD_H || _LIBC
# include <unistd.h>
#endif

#include <sys/stat.h>
#if STAT_MACROS_BROKEN
# undef S_ISDIR
#endif
#if !defined S_ISDIR && defined S_IFDIR
# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
#endif
#if !S_IRUSR && S_IREAD
# define S_IRUSR S_IREAD
#endif
#if !S_IRUSR
# define S_IRUSR 00400
#endif
#if !S_IWUSR && S_IWRITE
# define S_IWUSR S_IWRITE
#endif
#if !S_IWUSR
# define S_IWUSR 00200
#endif
#if !S_IXUSR && S_IEXEC
# define S_IXUSR S_IEXEC
#endif
#if !S_IXUSR
# define S_IXUSR 00100
#endif

#if _LIBC
# define struct_stat64 struct stat64
#else
# define struct_stat64 struct stat
# define __getpid getpid
# define __gettimeofday gettimeofday
# define __mkdir mkdir
# define __open open
# define __open64 open
# define __lxstat64(version, path, buf) lstat (path, buf)
# define __xstat64(version, path, buf) stat (path, buf)
#endif

#if ! (HAVE___SECURE_GETENV || _LIBC)
# define __secure_getenv getenv
#endif

#ifdef _LIBC
# include <hp-timing.h>
# if HP_TIMING_AVAIL
#  define RANDOM_BITS(Var) \
  if (__builtin_expect (value == UINT64_C (0), 0))			      \
    {									      \
      /* If this is the first time this function is used initialize	      \
	 the variable we accumulate the value in to some somewhat	      \
	 random value.  If we'd not do this programs at startup time	      \
	 might have a reduced set of possible names, at least on slow	      \
	 machines.  */							      \
      struct timeval tv;						      \
      __gettimeofday (&tv, NULL);					      \
      value = ((uint64_t) tv.tv_usec << 16) ^ tv.tv_sec;		      \
    }									      \
  HP_TIMING_NOW (Var)
# endif
#endif

/* Use the widest available unsigned type if uint64_t is not
   available.  The algorithm below extracts a number less than 62**6
   (approximately 2**35.725) from uint64_t, so ancient hosts where
   uintmax_t is only 32 bits lose about 3.725 bits of randomness,
   which is better than not having mkstemp at all.  */
#if !defined UINT64_MAX && !defined uint64_t
# define uint64_t uintmax_t
#endif

/* Return nonzero if DIR is an existent directory.  */
static int
direxists (const char *dir)
{
  struct_stat64 buf;
  return __xstat64 (_STAT_VER, dir, &buf) == 0 && S_ISDIR (buf.st_mode);
}

/* 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)
{
  const char *d;
  size_t dlen, plen;

  if (!pfx || !pfx[0])
    {
      pfx = "file";
      plen = 4;
    }
  else
    {
      plen = strlen (pfx);
      if (plen > 5)
	plen = 5;
    }

  if (try_tmpdir)
    {
      d = __secure_getenv ("TMPDIR");
      if (d != NULL && direxists (d))
	dir = d;
      else if (dir != NULL && direxists (dir))
	/* nothing */ ;
      else
	dir = NULL;
    }
  if (dir == NULL)
    {
      if (direxists (P_tmpdir))
	dir = P_tmpdir;
      else if (strcmp (P_tmpdir, "/tmp") != 0 && direxists ("/tmp"))
	dir = "/tmp";
      else
	{
	  __set_errno (ENOENT);
	  return -1;
	}
    }

  dlen = strlen (dir);
  while (dlen > 1 && dir[dlen - 1] == '/')
    dlen--;			/* remove trailing slashes */

  /* check we have room for "${dir}/${pfx}XXXXXX\0" */
  if (tmpl_len < dlen + 1 + plen + 6 + 1)
    {
      __set_errno (EINVAL);
      return -1;
    }

  sprintf (tmpl, "%.*s/%.*sXXXXXX", (int) dlen, dir, (int) plen, pfx);
  return 0;
}

/* 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.

   KIND may be one of:
   __GT_NOCREATE:	simply verify that the name does not exist
			at the time of the call.
   __GT_FILE:		create the file using open(O_CREAT|O_EXCL)
			and return a read-write fd.  The file is mode 0600.
   __GT_BIGFILE:	same as __GT_FILE but use open64().
   __GT_DIR:		create a directory, which will be mode 0700.

   We use a clever algorithm to get hard-to-predict names. */
int
__gen_tempname (char *tmpl, int kind)
{
  int len;
  char *XXXXXX;
  static uint64_t value;
  uint64_t random_time_bits;
  unsigned int count;
  int fd = -1;
  int save_errno = errno;
  struct_stat64 st;

  /* A lower bound on the number of temporary files to attempt to
     generate.  The maximum total number of temporary file names that
     can exist for a given template is 62**6.  It should never be
     necessary to try all these combinations.  Instead if a reasonable
     number of names is tried (we define reasonable as 62**3) fail to
     give the system administrator the chance to remove the problems.  */
  unsigned int attempts_min = 62 * 62 * 62;

  /* The number of times to attempt to generate a temporary file.  To
     conform to POSIX, this must be no smaller than TMP_MAX.  */
  unsigned int attempts = attempts_min < TMP_MAX ? TMP_MAX : attempts_min;

  len = strlen (tmpl);
  if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
    {
      __set_errno (EINVAL);
      return -1;
    }

  /* This is where the Xs start.  */
  XXXXXX = &tmpl[len - 6];

  /* Get some more or less random data.  */
#ifdef RANDOM_BITS
  RANDOM_BITS (random_time_bits);
#else
# if HAVE_GETTIMEOFDAY || _LIBC
  {
    struct timeval tv;
    __gettimeofday (&tv, NULL);
    random_time_bits = ((uint64_t) tv.tv_usec << 16) ^ tv.tv_sec;
  }
# else
  random_time_bits = time (NULL);
# endif
#endif
  value += random_time_bits ^ __getpid ();

  for (count = 0; count < attempts; value += 7777, ++count)
    {
      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];

      switch (kind)
	{
	case __GT_FILE:
	  fd = __open (tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
	  break;

	case __GT_BIGFILE:
	  fd = __open64 (tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
	  break;

	case __GT_DIR:
	  fd = __mkdir (tmpl, S_IRUSR | S_IWUSR | S_IXUSR);
	  break;

	case __GT_NOCREATE:
	  /* This case is backward from the other three.  __gen_tempname
	     succeeds if __xstat fails because the name does not exist.
	     Note the continue to bypass the common logic at the bottom
	     of the loop.  */
	  if (__lxstat64 (_STAT_VER, tmpl, &st) < 0)
	    {
	      if (errno == ENOENT)
		{
		  __set_errno (save_errno);
		  return 0;
		}
	      else
		/* Give up now. */
		return -1;
	    }
	  continue;

	default:
	  assert (! "invalid KIND in __gen_tempname");
	}

      if (fd >= 0)
	{
	  __set_errno (save_errno);
	  return fd;
	}
      else if (errno != EEXIST)
	return -1;
    }

  /* We got out of the loop because we ran out of combinations to try.  */
  __set_errno (EEXIST);
  return -1;
}
Commit	Line	Data
381fb12e AD	1	/* Copyright (C) 1991-1999, 2000, 2001 Free Software Foundation, Inc.
	2	This file is part of the GNU C Library.
	3
9742c552 PE	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 2, or (at your option)
	7	any later version.
381fb12e	8
9742c552	9	This program is distributed in the hope that it will be useful,
381fb12e	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
9742c552 PE	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9742c552 PE	12	GNU General Public License for more details.
381fb12e	13
9742c552 PE	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, write to the Free Software Foundation,
	16	Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
381fb12e AD	17
	18	#if HAVE_CONFIG_H
	19	# include <config.h>
	20	#endif
	21
	22	#include <sys/types.h>
	23	#include <assert.h>
	24
	25	#include <errno.h>
	26	#ifndef __set_errno
	27	# define __set_errno(Val) errno = (Val)
	28	#endif
	29
	30	#include <stdio.h>
	31	#ifndef P_tmpdir
	32	# define P_tmpdir "/tmp"
	33	#endif
	34	#ifndef TMP_MAX
	35	# define TMP_MAX 238328
	36	#endif
	37	#ifndef __GT_FILE
	38	# define __GT_FILE 0
	39	# define __GT_BIGFILE 1
	40	# define __GT_DIR 2
	41	# define __GT_NOCREATE 3
	42	#endif
	43
	44	#if STDC_HEADERS \|\| _LIBC
	45	# include <stddef.h>
	46	# include <string.h>
	47	#endif
	48
	49	#include <stdlib.h>
	50
	51	#if HAVE_FCNTL_H \|\| _LIBC
	52	# include <fcntl.h>
	53	#endif
	54
	55	#if HAVE_SYS_TIME_H \|\| _LIBC
	56	# include <sys/time.h>
	57	#endif
	58
	59	#if HAVE_STDINT_H \|\| _LIBC
	60	# include <stdint.h>
	61	#endif
	62
	63	#if HAVE_UNISTD_H \|\| _LIBC
	64	# include <unistd.h>
	65	#endif
	66
	67	#include <sys/stat.h>
	68	#if STAT_MACROS_BROKEN
	69	# undef S_ISDIR
	70	#endif
	71	#if !defined S_ISDIR && defined S_IFDIR
	72	# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
	73	#endif
	74	#if !S_IRUSR && S_IREAD
	75	# define S_IRUSR S_IREAD
	76	#endif
	77	#if !S_IRUSR
	78	# define S_IRUSR 00400
	79	#endif
	80	#if !S_IWUSR && S_IWRITE
81	# define S_IWUSR S_IWRITE
82	#endif
83	#if !S_IWUSR
84	# define S_IWUSR 00200
85	#endif
86	#if !S_IXUSR && S_IEXEC
87	# define S_IXUSR S_IEXEC
88	#endif
89	#if !S_IXUSR
90	# define S_IXUSR 00100
91	#endif
92
93	#if _LIBC
94	# define struct_stat64 struct stat64
95	#else
96	# define struct_stat64 struct stat
97	# define __getpid getpid
98	# define __gettimeofday gettimeofday
99	# define __mkdir mkdir
100	# define __open open
101	# define __open64 open
102	# define __lxstat64(version, path, buf) lstat (path, buf)
103	# define __xstat64(version, path, buf) stat (path, buf)
104	#endif
105
106	#if ! (HAVE___SECURE_GETENV \|\| _LIBC)
107	# define __secure_getenv getenv
108	#endif
109
110	#ifdef _LIBC
111	# include <hp-timing.h>
112	# if HP_TIMING_AVAIL
113	# define RANDOM_BITS(Var) \
114	if (__builtin_expect (value == UINT64_C (0), 0)) \
115	{ \
116	/* If this is the first time this function is used initialize \
117	the variable we accumulate the value in to some somewhat \
118	random value. If we'd not do this programs at startup time \
119	might have a reduced set of possible names, at least on slow \
120	machines. */ \
121	struct timeval tv; \
122	__gettimeofday (&tv, NULL); \
123	value = ((uint64_t) tv.tv_usec << 16) ^ tv.tv_sec; \
124	} \
125	HP_TIMING_NOW (Var)
126	# endif
127	#endif
128
129	/* Use the widest available unsigned type if uint64_t is not
130	available. The algorithm below extracts a number less than 62**6
131	(approximately 2**35.725) from uint64_t, so ancient hosts where
132	uintmax_t is only 32 bits lose about 3.725 bits of randomness,
133	which is better than not having mkstemp at all. */
134	#if !defined UINT64_MAX && !defined uint64_t
135	# define uint64_t uintmax_t
136	#endif
137
138	/* Return nonzero if DIR is an existent directory. */
139	static int
140	direxists (const char *dir)
141	{
142	struct_stat64 buf;
143	return __xstat64 (_STAT_VER, dir, &buf) == 0 && S_ISDIR (buf.st_mode);
144	}
145
146	/* Path search algorithm, for tmpnam, tmpfile, etc. If DIR is
147	non-null and exists, uses it; otherwise uses the first of $TMPDIR,
148	P_tmpdir, /tmp that exists. Copies into TMPL a template suitable
149	for use with mk[s]temp. Will fail (-1) if DIR is non-null and
150	doesn't exist, none of the searched dirs exists, or there's not
151	enough space in TMPL. */
152	int
153	__path_search (char tmpl, size_t tmpl_len, const char dir, const char *pfx,
154	int try_tmpdir)
155	{
156	const char *d;
157	size_t dlen, plen;
158
159	if (!pfx \|\| !pfx[0])
160	{
161	pfx = "file";
162	plen = 4;
163	}
164	else
165	{
166	plen = strlen (pfx);
167	if (plen > 5)
168	plen = 5;
169	}
170
171	if (try_tmpdir)
172	{
173	d = __secure_getenv ("TMPDIR");
174	if (d != NULL && direxists (d))
175	dir = d;
176	else if (dir != NULL && direxists (dir))
177	/* nothing */ ;
178	else
179	dir = NULL;
180	}
181	if (dir == NULL)
182	{
183	if (direxists (P_tmpdir))
184	dir = P_tmpdir;
185	else if (strcmp (P_tmpdir, "/tmp") != 0 && direxists ("/tmp"))
186	dir = "/tmp";
187	else
188	{
189	__set_errno (ENOENT);
190	return -1;
191	}
192	}
193
194	dlen = strlen (dir);
195	while (dlen > 1 && dir[dlen - 1] == '/')
196	dlen--; /* remove trailing slashes */
197
198	/* check we have room for "${dir}/${pfx}XXXXXX\0" */
199	if (tmpl_len < dlen + 1 + plen + 6 + 1)
200	{
201	__set_errno (EINVAL);
202	return -1;
203	}
204
205	sprintf (tmpl, "%.s/%.sXXXXXX", (int) dlen, dir, (int) plen, pfx);
206	return 0;
207	}
208
209	/* These are the characters used in temporary filenames. */
210	static const char letters[] =
211	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
212
213	/* Generate a temporary file name based on TMPL. TMPL must match the
214	rules for mk[s]temp (i.e. end in "XXXXXX"). The name constructed
215	does not exist at the time of the call to __gen_tempname. TMPL is
216	overwritten with the result.
217
218	KIND may be one of:
219	__GT_NOCREATE: simply verify that the name does not exist
220	at the time of the call.
221	__GT_FILE: create the file using open(O_CREAT\|O_EXCL)
222	and return a read-write fd. The file is mode 0600.
223	__GT_BIGFILE: same as __GT_FILE but use open64().
224	__GT_DIR: create a directory, which will be mode 0700.
225
226	We use a clever algorithm to get hard-to-predict names. */
227	int
228	__gen_tempname (char *tmpl, int kind)
229	{
230	int len;
231	char *XXXXXX;
232	static uint64_t value;
233	uint64_t random_time_bits;
234	unsigned int count;
235	int fd = -1;
236	int save_errno = errno;
237	struct_stat64 st;
238
239	/* A lower bound on the number of temporary files to attempt to
240	generate. The maximum total number of temporary file names that
241	can exist for a given template is 62**6. It should never be
242	necessary to try all these combinations. Instead if a reasonable
243	number of names is tried (we define reasonable as 62**3) fail to
244	give the system administrator the chance to remove the problems. */
245	unsigned int attempts_min = 62 * 62 * 62;
246
247	/* The number of times to attempt to generate a temporary file. To
248	conform to POSIX, this must be no smaller than TMP_MAX. */
249	unsigned int attempts = attempts_min < TMP_MAX ? TMP_MAX : attempts_min;
250
251	len = strlen (tmpl);
252	if (len < 6 \|\| strcmp (&tmpl[len - 6], "XXXXXX"))
253	{
254	__set_errno (EINVAL);
255	return -1;
256	}
257
258	/* This is where the Xs start. */
259	XXXXXX = &tmpl[len - 6];
260
261	/* Get some more or less random data. */
262	#ifdef RANDOM_BITS
263	RANDOM_BITS (random_time_bits);
264	#else
265	# if HAVE_GETTIMEOFDAY \|\| _LIBC
266	{
267	struct timeval tv;
268	__gettimeofday (&tv, NULL);
269	random_time_bits = ((uint64_t) tv.tv_usec << 16) ^ tv.tv_sec;
270	}
271	# else
272	random_time_bits = time (NULL);
273	# endif
274	#endif
275	value += random_time_bits ^ __getpid ();
276
277	for (count = 0; count < attempts; value += 7777, ++count)
278	{
279	uint64_t v = value;
280
281	/* Fill in the random bits. */
282	XXXXXX[0] = letters[v % 62];
283	v /= 62;
284	XXXXXX[1] = letters[v % 62];
285	v /= 62;
286	XXXXXX[2] = letters[v % 62];
287	v /= 62;
288	XXXXXX[3] = letters[v % 62];
289	v /= 62;
290	XXXXXX[4] = letters[v % 62];
291	v /= 62;
292	XXXXXX[5] = letters[v % 62];
293
294	switch (kind)
295	{
296	case __GT_FILE:
297	fd = __open (tmpl, O_RDWR \| O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR);
298	break;
299
300	case __GT_BIGFILE:
301	fd = __open64 (tmpl, O_RDWR \| O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR);
302	break;
303
304	case __GT_DIR:
305	fd = __mkdir (tmpl, S_IRUSR \| S_IWUSR \| S_IXUSR);
306	break;
307
308	case __GT_NOCREATE:
309	/* This case is backward from the other three. __gen_tempname
310	succeeds if __xstat fails because the name does not exist.
311	Note the continue to bypass the common logic at the bottom
312	of the loop. */
313	if (__lxstat64 (_STAT_VER, tmpl, &st) < 0)
314	{
315	if (errno == ENOENT)
316	{
317	__set_errno (save_errno);
318	return 0;
319	}
320	else
321	/* Give up now. */
322	return -1;
323	}
324	continue;
325
326	default:
327	assert (! "invalid KIND in __gen_tempname");
328	}
329
330	if (fd >= 0)
331	{
332	__set_errno (save_errno);
333	return fd;
334	}
335	else if (errno != EEXIST)
336	return -1;
337	}
338
339	/* We got out of the loop because we ran out of combinations to try. */
340	__set_errno (EEXIST);
341	return -1;
342	}