[thirdparty/glibc.git] / sysdeps / posix / tempname.c

/* Copyright (C) 1991-1999, 2000, 2001 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 Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; 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 <stdlib.h>
# include <string.h>
#endif

#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
a334319f	1	/* Copyright (C) 1991-1999, 2000, 2001 Free Software Foundation, Inc.
478b92f0	2	This file is part of the GNU C Library.
28f540f4	3
478b92f0	4	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	5	modify it under the terms of the GNU Lesser General Public
	6	License as published by the Free Software Foundation; either
	7	version 2.1 of the License, or (at your option) any later version.
28f540f4	8
478b92f0 UD	9	The GNU C Library 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 GNU
41bdb6e2	12	Lesser General Public License for more details.
28f540f4	13
41bdb6e2 AJ	14	You should have received a copy of the GNU Lesser General Public
	15	License along with the GNU C Library; if not, write to the Free
	16	Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	17	02111-1307 USA. */
28f540f4	18
46c3f8cd UD	19	#if HAVE_CONFIG_H
	20	# include <config.h>
	21	#endif
	22
28f540f4	23	#include <sys/types.h>
2e65ca2b	24	#include <assert.h>
28f540f4	25
46c3f8cd UD	26	#include <errno.h>
	27	#ifndef __set_errno
	28	# define __set_errno(Val) errno = (Val)
	29	#endif
	30
	31	#include <stdio.h>
	32	#ifndef P_tmpdir
	33	# define P_tmpdir "/tmp"
	34	#endif
	35	#ifndef TMP_MAX
	36	# define TMP_MAX 238328
	37	#endif
	38	#ifndef __GT_FILE
	39	# define __GT_FILE 0
	40	# define __GT_BIGFILE 1
	41	# define __GT_DIR 2
	42	# define __GT_NOCREATE 3
	43	#endif
	44
	45	#if STDC_HEADERS \|\| _LIBC
	46	# include <stddef.h>
	47	# include <stdlib.h>
	48	# include <string.h>
	49	#endif
	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
3b5c1b57 UD	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
f2615995 UD	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
28f540f4 RM	138	/* Return nonzero if DIR is an existent directory. */
28f540f4 RM	139	static int
7cabd57c	140	direxists (const char *dir)
28f540f4	141	{
46c3f8cd	142	struct_stat64 buf;
8edf6e0d	143	return __xstat64 (_STAT_VER, dir, &buf) == 0 && S_ISDIR (buf.st_mode);
28f540f4 RM	144	}
28f540f4 RM	145
7cabd57c UD	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
60876a75 UD	153	__path_search (char tmpl, size_t tmpl_len, const char dir, const char *pfx,
60876a75 UD	154	int try_tmpdir)
28f540f4	155	{
7cabd57c UD	156	const char *d;
	157	size_t dlen, plen;
	158
	159	if (!pfx \|\| !pfx[0])
	160	{
	161	pfx = "file";
	162	plen = 4;
	163	}
28f540f4 RM	164	else
28f540f4 RM	165	{
7cabd57c UD	166	plen = strlen (pfx);
	167	if (plen > 5)
	168	plen = 5;
28f540f4	169	}
28f540f4	170
60876a75 UD	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 */ ;
5a7cb1a2 UD	178	else
5a7cb1a2 UD	179	dir = NULL;
60876a75	180	}
e9dcb080	181	if (dir == NULL)
28f540f4	182	{
b61af6fc UD	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	}
28f540f4	192	}
28f540f4 RM	193
28f540f4 RM	194	dlen = strlen (dir);
28f540f4	195	while (dlen > 1 && dir[dlen - 1] == '/')
7cabd57c	196	dlen--; /* remove trailing slashes */
28f540f4	197
7cabd57c UD	198	/* check we have room for "${dir}/${pfx}XXXXXX\0" */
7cabd57c UD	199	if (tmpl_len < dlen + 1 + plen + 6 + 1)
28f540f4	200	{
7cabd57c UD	201	__set_errno (EINVAL);
7cabd57c UD	202	return -1;
28f540f4	203	}
28f540f4	204
04166d6e	205	sprintf (tmpl, "%.s/%.sXXXXXX", (int) dlen, dir, (int) plen, pfx);
7cabd57c UD	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
2e65ca2b UD	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.
7cabd57c UD	225
	226	We use a clever algorithm to get hard-to-predict names. */
	227	int
2e65ca2b	228	__gen_tempname (char *tmpl, int kind)
7cabd57c UD	229	{
	230	int len;
	231	char *XXXXXX;
	232	static uint64_t value;
46c3f8cd	233	uint64_t random_time_bits;
8e9b2075 UD	234	unsigned int count;
8e9b2075 UD	235	int fd = -1;
7cabd57c	236	int save_errno = errno;
46c3f8cd	237	struct_stat64 st;
28f540f4	238
8e9b2075 UD	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. */
a334319f	245	unsigned int attempts_min = 62 * 62 * 62;
8e9b2075 UD	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. */
a334319f	249	unsigned int attempts = attempts_min < TMP_MAX ? TMP_MAX : attempts_min;
8e9b2075	250
7cabd57c UD	251	len = strlen (tmpl);
	252	if (len < 6 \|\| strcmp (&tmpl[len - 6], "XXXXXX"))
	253	{
a7ab2023	254	__set_errno (EINVAL);
7cabd57c UD	255	return -1;
7cabd57c UD	256	}
28f540f4	257
7cabd57c UD	258	/* This is where the Xs start. */
7cabd57c UD	259	XXXXXX = &tmpl[len - 6];
d68171ed	260
a7ab2023	261	/* Get some more or less random data. */
f2615995 UD	262	#ifdef RANDOM_BITS
	263	RANDOM_BITS (random_time_bits);
	264	#else
	265	# if HAVE_GETTIMEOFDAY \|\| _LIBC
46c3f8cd UD	266	{
	267	struct timeval tv;
	268	__gettimeofday (&tv, NULL);
	269	random_time_bits = ((uint64_t) tv.tv_usec << 16) ^ tv.tv_sec;
	270	}
f2615995	271	# else
46c3f8cd	272	random_time_bits = time (NULL);
f2615995	273	# endif
46c3f8cd UD	274	#endif
46c3f8cd UD	275	value += random_time_bits ^ __getpid ();
28f540f4	276
8e9b2075	277	for (count = 0; count < attempts; value += 7777, ++count)
a7ab2023 UD	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];
28f540f4	293
2e65ca2b	294	switch (kind)
7cabd57c	295	{
2e65ca2b	296	case __GT_FILE:
46c3f8cd	297	fd = __open (tmpl, O_RDWR \| O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR);
2e65ca2b UD	298	break;
	299
	300	case __GT_BIGFILE:
46c3f8cd	301	fd = __open64 (tmpl, O_RDWR \| O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR);
2e65ca2b UD	302	break;
	303
	304	case __GT_DIR:
46c3f8cd	305	fd = __mkdir (tmpl, S_IRUSR \| S_IWUSR \| S_IXUSR);
2e65ca2b UD	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. */
72c65ff4	313	if (__lxstat64 (_STAT_VER, tmpl, &st) < 0)
7cabd57c UD	314	{
7cabd57c UD	315	if (errno == ENOENT)
28f540f4	316	{
7cabd57c UD	317	__set_errno (save_errno);
7cabd57c UD	318	return 0;
28f540f4	319	}
7cabd57c UD	320	else
	321	/* Give up now. */
	322	return -1;
28f540f4	323	}
2e65ca2b UD	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;
28f540f4	334	}
2e65ca2b UD	335	else if (errno != EEXIST)
2e65ca2b UD	336	return -1;
28f540f4 RM	337	}
	338
	339	/* We got out of the loop because we ran out of combinations to try. */
7cabd57c UD	340	__set_errno (EEXIST);
7cabd57c UD	341	return -1;
28f540f4	342	}