entered into RCS
[kopensolaris-gnu/glibc.git] / sysdeps / posix / tempname.c
1 /* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
8
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
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB.  If
16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
17 Cambridge, MA 02139, USA.  */
18
19 #include <ansidecl.h>
20 #include <errno.h>
21 #include <stddef.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/types.h>
26 #include <sys/stat.h>
27 #include <fcntl.h>
28 #include <unistd.h>
29
30 /* Return nonzero if DIR is an existent directory.  */
31 static int
32 DEFUN(diraccess, (dir), CONST char *dir)
33 {
34   struct stat buf;
35   return __stat (dir, &buf) == 0 && S_ISDIR (buf.st_mode);
36 }
37
38 /* Return nonzero if FILE exists.  */
39 static int
40 DEFUN(exists, (file), CONST char *file)
41 {
42   /* We can stat the file even if we can't read its data.  */
43   struct stat st;
44   int save = errno;
45   if (__stat (file, &st) == 0)
46     return 1;
47   else
48     {
49       /* We report that the file exists if stat failed for a reason other
50          than nonexistence.  In this case, it may or may not exist, and we
51          don't know; but reporting that it does exist will never cause any
52          trouble, while reporting that it doesn't exist when it does would
53          violate the interface of __stdio_gen_tempname.  */
54       int exists = errno != ENOENT;
55       errno = save;
56       return exists;
57     }
58 }
59
60
61 /* These are the characters used in temporary filenames.  */
62 static CONST char letters[] =
63   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
64
65 /* Generate a temporary filename and return it (in a static buffer).  If
66    STREAMPTR is not NULL, open a stream "w+b" on the file and set
67    *STREAMPTR to it.  If DIR_SEARCH is nonzero, DIR and PFX are used as
68    described for tempnam.  If not, a temporary filename in P_tmpdir with no
69    special prefix is generated.  If LENPTR is not NULL, *LENPTR is set the
70    to length (including the terminating '\0') of the resultant filename,
71    which is returned.  This goes through a cyclic pattern of all possible
72    filenames consisting of five decimal digits of the current pid and three
73    of the characters in `letters'.  Data for tempnam and tmpnam is kept
74    separate, but when tempnam is using P_tmpdir and no prefix (i.e, it is
75    identical to tmpnam), the same data is used.  Each potential filename is
76    tested for an already-existing file of the same name, and no name of an
77    existing file will be returned.  When the cycle reaches its end
78    (12345ZZZ), NULL is returned.  */
79 char *
80 DEFUN(__stdio_gen_tempname, (dir, pfx, dir_search, lenptr, streamptr),
81       CONST char *dir AND CONST char *pfx AND
82       int dir_search AND size_t *lenptr AND
83       FILE **streamptr)
84 {
85   int saverrno = errno;
86   static CONST char tmpdir[] = P_tmpdir;
87   static size_t indices[2];
88   size_t *idx;
89   static char buf[FILENAME_MAX];
90   static pid_t oldpid = (pid_t) 0;
91   pid_t pid = __getpid();
92   register size_t len, plen, dlen;
93
94   if (dir_search)
95     {
96       register CONST char *d = getenv("TMPDIR");
97       if (d != NULL && !diraccess(d))
98         d = NULL;
99       if (d == NULL && dir != NULL && diraccess(dir))
100         d = dir;
101       if (d == NULL && diraccess(tmpdir))
102         d = tmpdir;
103       if (d == NULL && diraccess("/tmp"))
104         d = "/tmp";
105       if (d == NULL)
106         {
107           errno = ENOENT;
108           return NULL;
109         }
110       dir = d;
111     }
112   else
113     dir = tmpdir;
114
115   dlen = strlen (dir);
116
117   /* Remove trailing slashes from the directory name.  */
118   while (dlen > 1 && dir[dlen - 1] == '/')
119     --dlen;
120
121   if (pfx != NULL && *pfx != '\0')
122     {
123       plen = strlen(pfx);
124       if (plen > 5)
125         plen = 5;
126     }
127   else
128     plen = 0;
129
130   if (dir != tmpdir && !strcmp(dir, tmpdir))
131     dir = tmpdir;
132   idx = &indices[(plen == 0 && dir == tmpdir) ? 1 : 0];
133
134   if (pid != oldpid)
135     {
136       oldpid = pid;
137       indices[0] = indices[1] = 0;
138     }
139
140   len = dlen + 1 + plen + 5 + 3;
141   for (; *idx < ((sizeof (letters) - 1) * (sizeof (letters) - 1) *
142                  (sizeof (letters) - 1));
143        ++*idx)
144     {
145       /* Construct a file name and see if it already exists.
146
147          We use a single counter in *IDX to cycle each of three
148          character positions through each of 62 possible letters.  */
149
150       if (sizeof (buf) < len ||
151           sprintf (buf, "%.*s/%.*s%.5d%c%c%c",
152                    (int) dlen, dir, (int) plen,
153                    pfx, pid % 100000,
154                    letters[*idx
155                            % (sizeof (letters) - 1)],
156                    letters[(*idx / (sizeof (letters) - 1))
157                            % (sizeof (letters) - 1)],
158                    letters[(*idx / ((sizeof (letters) - 1) *
159                                     (sizeof (letters) - 1)))
160                            % (sizeof (letters) - 1)]
161                    ) != (int) len)
162         return NULL;
163
164       if (streamptr != NULL)
165         {
166           /* Try to create the file atomically.  */
167           int fd = __open (buf, O_RDWR|O_CREAT|O_EXCL, 0666);
168           if (fd >= 0)
169             {
170               /* We got a new file that did not previously exist.
171                  Create a stream for it.  */
172               *streamptr = __newstream ();
173               if (*streamptr == NULL)
174                 {
175                   /* We lost trying to create a stream (out of memory?).
176                      Nothing to do but remove the file, close the descriptor,
177                      and return failure.  */
178                   const int save = errno;
179                   (void) remove (buf);
180                   (void) __close (fd);
181                   errno = save;
182                   return NULL;
183                 }
184               (*streamptr)->__cookie = (PTR) fd;
185               (*streamptr)->__mode.__write = 1;
186               (*streamptr)->__mode.__read = 1;
187               (*streamptr)->__mode.__binary = 1;
188             }
189           else
190             continue;
191         }
192       else if (exists (buf))
193         continue;
194
195       /* If the file already existed we have continued the loop above,
196          so we only get here when we have a winning name to return.  */
197
198       errno = saverrno;
199
200       if (lenptr != NULL)
201         *lenptr = len + 1;
202       return buf;
203     }
204
205   /* We got out of the loop because we ran out of combinations to try.  */
206   errno = EEXIST;               /* ? */
207   return NULL;
208 }