Subversion Repositories openrisc_me

/*

 * 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>>, <<mkstemps>>---generate unused file name

<<mkdtemp>>---generate unused directory

INDEX

        mktemp

INDEX

        mkdtemp

INDEX

        mkstemp

INDEX

        mkstemps

INDEX

        _mktemp_r

INDEX

        _mkdtemp_r

INDEX

        _mkstemp_r

INDEX

        _mkstemps_r

ANSI_SYNOPSIS

        #include <stdlib.h>

        char *mktemp(char *<[path]>);

        char *mkdtemp(char *<[path]>);

        int mkstemp(char *<[path]>);

        int mkstemps(char *<[path]>, int <[suffixlen]>);

        char *_mktemp_r(struct _reent *<[reent]>, char *<[path]>);

        char *_mkdtemp_r(struct _reent *<[reent]>, char *<[path]>);

        int *_mkstemp_r(struct _reent *<[reent]>, char *<[path]>);

        int *_mkstemps_r(struct _reent *<[reent]>, char *<[path]>, int <[len]>);

DESCRIPTION

<<mktemp>>, <<mkstemp>>, and <<mkstemps>> attempt to generate a file name

that is not yet in use for any existing file.  <<mkstemp>> and <<mkstemps>>

create the file and open it for reading and writing; <<mktemp>> simply

generates the file name (making <<mktemp>> a security risk).  <<mkdtemp>>

attempts to create a directory instead of a file, with a permissions

mask of 0700.

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 at least six `<<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.  With <<mkstemps>>, the `<<X>>'

characters end <[suffixlen]> bytes before the end of the string.

The alternate functions <<_mktemp_r>>, <<_mkdtemp_r>>, <<_mkstemp_r>>,

and <<_mkstemps_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>>.

<<mkdtemp>> returns the pointer <[path]> to the modified string if the

directory was created, otherwise it returns <<NULL>>.

<<mkstemp>> and <<mkstemps>> return 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>>.

NOTES

Never use <<mktemp>>.  The generated filenames are easy to guess and

there's a race between the test if the file exists and the creation

of the file.  In combination this makes <<mktemp>> prone to attacks

and using it is a security risk.  Whenever possible use <<mkstemp>>

instead.  It doesn't suffer the race condition.

PORTABILITY

ANSI C does not require either <<mktemp>> or <<mkstemp>>; the System

V Interface Definition requires <<mktemp>> as of Issue 2.  POSIX 2001

requires <<mkstemp>>, and POSIX 2008 requires <<mkdtemp>>, but

<<mkstemps>> is not standardized.

Supporting OS subroutines required: <<getpid>>, <<mkdir>>, <<open>>, <<stat>>.

*/

#include <_ansi.h>

#include <stdlib.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, domkdir, suffixlen),

       struct _reent *ptr _AND

       char *path         _AND

       register int *doopen _AND

       int domkdir        _AND

       size_t suffixlen)

{

  register char *start, *trv;

  char *end;

#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;

  if (trv - path < suffixlen)

    {

      ptr->_errno = EINVAL;

      return 0;

    }

  trv -= suffixlen;

  end = trv;

  while (path < trv && *--trv == 'X')

    {

      *trv = (pid % 10) + '0';

      pid /= 10;

    }

  if (end - trv < 6)

    {

      ptr->_errno = EINVAL;

      return 0;

    }

  /*

   * 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 !defined _ELIX_LEVEL || _ELIX_LEVEL >= 4

      if (domkdir)

        {

#ifdef HAVE_MKDIR

          if (_mkdir_r (ptr, path, 0700) == 0)

            return 1;

          if (ptr->_errno != EEXIST)

            return 0;

#else /* !HAVE_MKDIR */

          ptr->_errno = ENOSYS;

          return 0;

#endif /* !HAVE_MKDIR */

        }

      else

#endif /* _ELIX_LEVEL */

      if (doopen)

        {

          if ((*doopen = _open_r (ptr, path, O_CREAT | O_EXCL | O_RDWR, 0600))

              >= 0)

            return 1;

          if (ptr->_errno != EEXIST)

            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 == end)

            return 0;

          if (*trv == 'z')

            *trv++ = 'a';

          else

            {

              /* Safe, since it only encounters 7-bit characters.  */

              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, 0, 0) ? fd : -1);

}

#if !defined _ELIX_LEVEL || _ELIX_LEVEL >= 4

char *

_DEFUN(_mkdtemp_r, (ptr, path),

       struct _reent *ptr _AND

       char *path)

{

  return (_gettemp (ptr, path, (int *) NULL, 1, 0) ? path : NULL);

}

int

_DEFUN(_mkstemps_r, (ptr, path, len),

       struct _reent *ptr _AND

       char *path _AND

       int len)

{

  int fd;

  return (_gettemp (ptr, path, &fd, 0, len) ? fd : -1);

}

#endif /* _ELIX_LEVEL */

char *

_DEFUN(_mktemp_r, (ptr, path),

       struct _reent *ptr _AND

       char *path)

{

  return (_gettemp (ptr, path, (int *) NULL, 0, 0) ? path : (char *) NULL);

}

#ifndef _REENT_ONLY

int

_DEFUN(mkstemp, (path),

       char *path)

{

  int fd;

  return (_gettemp (_REENT, path, &fd, 0, 0) ? fd : -1);

}

# if !defined _ELIX_LEVEL || _ELIX_LEVEL >= 4

char *

_DEFUN(mkdtemp, (path),

       char *path)

{

  return (_gettemp (_REENT, path, (int *) NULL, 1, 0) ? path : NULL);

}

int

_DEFUN(mkstemps, (path, len),

       char *path _AND

       int len)

{

  int fd;

  return (_gettemp (_REENT, path, &fd, 0, len) ? fd : -1);

}

# endif /* _ELIX_LEVEL */

char *

_DEFUN(mktemp, (path),

       char *path)

{

  return (_gettemp (_REENT, path, (int *) NULL, 0, 0) ? path : (char *) NULL);

}

#endif /* ! defined (_REENT_ONLY) */