Subversion Repositories openrisc

/*
 * Copyright (c) 1987 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that: (1) source distributions retain this entire copyright
 * notice and comment, and (2) distributions including binaries display
 * the following acknowledgement:  ``This product includes software
 * developed by the University of California, Berkeley and its contributors''
 * in the documentation or other materials provided with the distribution
 * and in all advertising materials mentioning features or use of this
 * software. Neither the name of the University nor the names of its
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */
/* This is file MKTEMP.C */
/* This file may have been modified by DJ Delorie (Jan 1991).  If so,
** these modifications are Copyright (C) 1991 DJ Delorie.
*/
 
/*
FUNCTION
<<mktemp>>, <<mkstemp>>---generate unused file name
 
INDEX
	mktemp
INDEX
	mkstemp
INDEX
	_mktemp_r
INDEX
	_mkstemp_r
 
ANSI_SYNOPSIS
	#include <stdio.h>
	char *mktemp(char *<[path]>);
	int mkstemp(char *<[path]>);
 
	char *_mktemp_r(struct _reent *<[reent]>, char *<[path]>);
	int *_mkstemp_r(struct _reent *<[reent]>, char *<[path]>);
 
TRAD_SYNOPSIS
	#include <stdio.h>
	char *mktemp(<[path]>)
	char *<[path]>;
 
	int mkstemp(<[path]>)
	char *<[path]>;
 
	char *_mktemp_r(<[reent]>, <[path]>)
	struct _reent *<[reent]>;
	char *<[path]>;
 
	int _mkstemp_r(<[reent]>, <[path]>)
	struct _reent *<[reent]>;
	char *<[path]>;
 
DESCRIPTION
<<mktemp>> and <<mkstemp>> attempt to generate a file name that is not
yet in use for any existing file.  <<mkstemp>> creates the file and
opens it for reading and writing; <<mktemp>> simply generates the file name.
 
You supply a simple pattern for the generated file name, as the string
at <[path]>.  The pattern should be a valid filename (including path
information if you wish) ending with some number of `<<X>>'
characters.  The generated filename will match the leading part of the
name you supply, with the trailing `<<X>>' characters replaced by some
combination of digits and letters.
 
The alternate functions <<_mktemp_r>> and <<_mkstemp_r>> are reentrant
versions.  The extra argument <[reent]> is a pointer to a reentrancy
structure.
 
RETURNS
<<mktemp>> returns the pointer <[path]> to the modified string
representing an unused filename, unless it could not generate one, or
the pattern you provided is not suitable for a filename; in that case,
it returns <<NULL>>.
 
<<mkstemp>> returns a file descriptor to the newly created file,
unless it could not generate an unused filename, or the pattern you
provided is not suitable for a filename; in that case, it returns
<<-1>>.
 
PORTABILITY
ANSI C does not require either <<mktemp>> or <<mkstemp>>; the System
V Interface Definition requires <<mktemp>> as of Issue 2.
 
Supporting OS subroutines required: <<getpid>>, <<open>>, <<stat>>.
*/
 
#include <_ansi.h>
#include <reent.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdio.h>
#include <ctype.h>
 
static int
_DEFUN(_gettemp, (ptr, path, doopen),
       struct _reent *ptr _AND
       char *path         _AND
       register int *doopen)
{
  register char *start, *trv;
#ifdef __USE_INTERNAL_STAT64
  struct stat64 sbuf;
#else
  struct stat sbuf;
#endif
  unsigned int pid;
 
  pid = _getpid_r (ptr);
  for (trv = path; *trv; ++trv)		/* extra X's get set to 0's */
    continue;
  while (*--trv == 'X')
    {
      *trv = (pid % 10) + '0';
      pid /= 10;
    }
 
  /*
   * Check the target directory; if you have six X's and it
   * doesn't exist this runs for a *very* long time.
   */
 
  for (start = trv + 1;; --trv)
    {
      if (trv <= path)
	break;
      if (*trv == '/')
	{
	  *trv = '\0';
#ifdef __USE_INTERNAL_STAT64
	  if (_stat64_r (ptr, path, &sbuf))
#else
	  if (_stat_r (ptr, path, &sbuf))
#endif
	    return (0);
	  if (!(sbuf.st_mode & S_IFDIR))
	    {
	      ptr->_errno = ENOTDIR;
	      return (0);
	    }
	  *trv = '/';
	  break;
	}
    }
 
  for (;;)
    {
      if (doopen)
	{
	  if ((*doopen = _open_r (ptr, path, O_CREAT | O_EXCL | O_RDWR, 0600))
	      >= 0)
	    return 1;
#if defined(__CYGWIN__)
	  if (ptr->_errno != EEXIST && ptr->_errno != EACCES)
#else
	  if (ptr->_errno != EEXIST)
#endif
	    return 0;
	}
#ifdef __USE_INTERNAL_STAT64
      else if (_stat64_r (ptr, path, &sbuf))
#else
      else if (_stat_r (ptr, path, &sbuf))
#endif
	return (ptr->_errno == ENOENT ? 1 : 0);
 
      /* tricky little algorithm for backward compatibility */
      for (trv = start;;)
	{
	  if (!*trv)
	    return 0;
	  if (*trv == 'z')
	    *trv++ = 'a';
	  else
	    {
	      if (isdigit (*trv))
		*trv = 'a';
	      else
		++ * trv;
	      break;
	    }
	}
    }
  /*NOTREACHED*/
}
 
int
_DEFUN(_mkstemp_r, (ptr, path),
       struct _reent *ptr _AND
       char *path)
{
  int fd;
 
  return (_gettemp (ptr, path, &fd) ? fd : -1);
}
 
char *
_DEFUN(_mktemp_r, (ptr, path),
       struct _reent *ptr _AND
       char *path)
{
  return (_gettemp (ptr, path, (int *) NULL) ? path : (char *) NULL);
}
 
#ifndef _REENT_ONLY
 
int
_DEFUN(mkstemp, (path),
       char *path)
{
  int fd;
 
  return (_gettemp (_REENT, path, &fd) ? fd : -1);
}
 
char *
_DEFUN(mktemp, (path),
       char *path)
{
  return (_gettemp (_REENT, path, (int *) NULL) ? path : (char *) NULL);
}
 
#endif /* ! defined (_REENT_ONLY) */