| 0,0 → 1,385 |
|---|
| /* |
| * 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>>, <<mkostemp>>, <<mkstemps>>, |
| <<mkostemps>>---generate unused file name |
| <<mkdtemp>>---generate unused directory |
| |
| INDEX |
| mktemp |
| INDEX |
| mkdtemp |
| INDEX |
| mkstemp |
| INDEX |
| mkstemps |
| INDEX |
| mkostemp |
| INDEX |
| mkostemps |
| INDEX |
| _mktemp_r |
| INDEX |
| _mkdtemp_r |
| INDEX |
| _mkstemp_r |
| INDEX |
| _mkstemps_r |
| INDEX |
| _mkostemp_r |
| INDEX |
| _mkostemps_r |
| |
| ANSI_SYNOPSIS |
| #include <stdlib.h> |
| char *mktemp(char *<[path]>); |
| char *mkdtemp(char *<[path]>); |
| int mkstemp(char *<[path]>); |
| int mkstemps(char *<[path]>, int <[suffixlen]>); |
| int mkostemp(char *<[path]>, int <[flags]>); |
| int mkostemps(char *<[path]>, int <[suffixlen]>, int <[flags]>); |
| |
| 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]>); |
| int *_mkostemp_r(struct _reent *<[reent]>, char *<[path]>, |
| int <[flags]>); |
| int *_mkostemps_r(struct _reent *<[reent]>, char *<[path]>, int <[len]>, |
| int <[flags]>); |
| |
| 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). <<mkostemp>> |
| and <<mkostemps>> allow the addition of other <<open>> flags, such |
| as <<O_CLOEXEC>>, <<O_APPEND>>, or <<O_SYNC>>. On platforms with a |
| separate text mode, <<mkstemp>> forces <<O_BINARY>>, while <<mkostemp>> |
| allows the choice between <<O_BINARY>>, <<O_TEXT>>, or 0 for default. |
| <<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>>, |
| <<_mkostemp_r>>, <<_mkostemps_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>>. Be aware that there is an inherent race between |
| generating the name and attempting to create a file by that name; |
| you are advised to use <<O_EXCL|O_CREAT>>. |
| |
| <<mkdtemp>> returns the pointer <[path]> to the modified string if the |
| directory was created, otherwise it returns <<NULL>>. |
| |
| <<mkstemp>>, <<mkstemps>>, <<mkostemp>>, and <<mkostemps>> 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>> while |
| deprecating <<mktemp>>. <<mkstemps>>, <<mkostemp>>, and <<mkostemps>> |
| are 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, flags), |
| struct _reent *ptr _AND |
| char *path _AND |
| register int *doopen _AND |
| int domkdir _AND |
| size_t suffixlen _AND |
| int flags) |
| { |
| 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 | flags, |
| 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 ((unsigned char) *trv)) |
| *trv = 'a'; |
| else |
| ++ * trv; |
| break; |
| } |
| } |
| } |
| /*NOTREACHED*/ |
| } |
| |
| #ifndef O_BINARY |
| # define O_BINARY 0 |
| #endif |
| |
| int |
| _DEFUN(_mkstemp_r, (ptr, path), |
| struct _reent *ptr _AND |
| char *path) |
| { |
| int fd; |
| |
| return (_gettemp (ptr, path, &fd, 0, 0, O_BINARY) ? 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, 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, O_BINARY) ? fd : -1); |
| } |
| |
| int |
| _DEFUN(_mkostemp_r, (ptr, path, flags), |
| struct _reent *ptr _AND |
| char *path _AND |
| int flags) |
| { |
| int fd; |
| |
| return (_gettemp (ptr, path, &fd, 0, 0, flags & ~O_ACCMODE) ? fd : -1); |
| } |
| |
| int |
| _DEFUN(_mkostemps_r, (ptr, path, len, flags), |
| struct _reent *ptr _AND |
| char *path _AND |
| int len _AND |
| int flags) |
| { |
| int fd; |
| |
| return (_gettemp (ptr, path, &fd, 0, len, flags & ~O_ACCMODE) ? 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, 0) ? path : (char *) NULL); |
| } |
| |
| #ifndef _REENT_ONLY |
| |
| int |
| _DEFUN(mkstemp, (path), |
| char *path) |
| { |
| int fd; |
| |
| return (_gettemp (_REENT, path, &fd, 0, 0, O_BINARY) ? fd : -1); |
| } |
| |
| # if !defined _ELIX_LEVEL || _ELIX_LEVEL >= 4 |
| char * |
| _DEFUN(mkdtemp, (path), |
| char *path) |
| { |
| return (_gettemp (_REENT, path, (int *) NULL, 1, 0, 0) ? path : NULL); |
| } |
| |
| int |
| _DEFUN(mkstemps, (path, len), |
| char *path _AND |
| int len) |
| { |
| int fd; |
| |
| return (_gettemp (_REENT, path, &fd, 0, len, O_BINARY) ? fd : -1); |
| } |
| |
| int |
| _DEFUN(mkostemp, (path, flags), |
| char *path _AND |
| int flags) |
| { |
| int fd; |
| |
| return (_gettemp (_REENT, path, &fd, 0, 0, flags & ~O_ACCMODE) ? fd : -1); |
| } |
| |
| int |
| _DEFUN(mkostemps, (path, len, flags), |
| char *path _AND |
| int len _AND |
| int flags) |
| { |
| int fd; |
| |
| return (_gettemp (_REENT, path, &fd, 0, len, flags & ~O_ACCMODE) ? fd : -1); |
| } |
| # endif /* _ELIX_LEVEL */ |
| |
| char * |
| _DEFUN(mktemp, (path), |
| char *path) |
| { |
| return (_gettemp (_REENT, path, (int *) NULL, 0, 0, 0) ? path : (char *) NULL); |
| } |
| |
| #endif /* ! defined (_REENT_ONLY) */ |