Add extra argument to trigger use of open64.
[kopensolaris-gnu/glibc.git] / sysdeps / posix / tempname.c
1 /* Copyright (C) 1991, 92, 93, 94, 95, 96, 97 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 not,
16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17    Boston, MA 02111-1307, USA.  */
18
19 #include <errno.h>
20 #include <stddef.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include <fcntl.h>
27 #include <unistd.h>
28
29 #ifdef USE_IN_LIBIO
30 # include "libioP.h"
31 # include <libio.h>
32 #endif
33
34 /* Return nonzero if DIR is an existent directory.  */
35 static int
36 diraccess (const char *dir)
37 {
38   struct stat buf;
39   return __stat (dir, &buf) == 0 && S_ISDIR (buf.st_mode);
40 }
41
42 /* Return nonzero if FILE exists.  */
43 static int
44 exists (const char *file)
45 {
46   /* We can stat the file even if we can't read its data.  */
47   struct stat st;
48   int save = errno;
49   if (__stat (file, &st) == 0)
50     return 1;
51   else
52     {
53       /* We report that the file exists if stat failed for a reason other
54          than nonexistence.  In this case, it may or may not exist, and we
55          don't know; but reporting that it does exist will never cause any
56          trouble, while reporting that it doesn't exist when it does would
57          violate the interface of __stdio_gen_tempname.  */
58       int exists = errno != ENOENT;
59       __set_errno (save);
60       return exists;
61     }
62 }
63
64
65 /* These are the characters used in temporary filenames.  */
66 static const char letters[] =
67   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
68
69 /* Generate a temporary filename and return it (in a static buffer).  If
70    STREAMPTR is not NULL, open a stream "w+b" on the file and set
71    *STREAMPTR to it.  If DIR_SEARCH is nonzero, DIR and PFX are used as
72    described for tempnam.  If not, a temporary filename in P_tmpdir with no
73    special prefix is generated.  If LENPTR is not NULL, *LENPTR is set the
74    to length (including the terminating '\0') of the resultant filename,
75    which is returned.  This goes through a cyclic pattern of all possible
76    filenames consisting of five decimal digits of the current pid and three
77    of the characters in `letters'.  Data for tempnam and tmpnam is kept
78    separate, but when tempnam is using P_tmpdir and no prefix (i.e, it is
79    identical to tmpnam), the same data is used.  Each potential filename is
80    tested for an already-existing file of the same name, and no name of an
81    existing file will be returned.  When the cycle reaches its end
82    (12345ZZZ), NULL is returned.  */
83 char *
84 __stdio_gen_tempname (char *buf, size_t bufsize, const char *dir,
85                       const char *pfx, int dir_search, size_t *lenptr,
86                       FILE **streamptr, int large_file)
87 {
88   int saverrno = errno;
89   static const char tmpdir[] = P_tmpdir;
90   static size_t indices[2];
91   size_t *idx;
92 #if 0
93   static pid_t oldpid = (pid_t) 0;
94 #endif
95   pid_t pid = __getpid();
96   register size_t len, plen, dlen;
97   int wrapped;
98
99   if (dir_search)
100     {
101       register const char *d = __secure_getenv ("TMPDIR");
102       if (d != NULL && !diraccess (d))
103         d = NULL;
104       if (d == NULL && dir != NULL && diraccess (dir))
105         d = dir;
106       if (d == NULL && diraccess (tmpdir))
107         d = tmpdir;
108       if (d == NULL && diraccess ("/tmp"))
109         d = "/tmp";
110       if (d == NULL)
111         {
112           __set_errno (ENOENT);
113           return NULL;
114         }
115       dir = d;
116     }
117   else
118     dir = tmpdir;
119
120   dlen = strlen (dir);
121
122  /* Remove trailing slashes from the directory name.  */
123   while (dlen > 1 && dir[dlen - 1] == '/')
124     --dlen;
125
126   if (pfx != NULL && *pfx != '\0')
127     {
128       plen = strlen (pfx);
129       if (plen > 5)
130         plen = 5;
131     }
132   else
133     plen = 0;
134
135   if (dir != tmpdir && !strcmp (dir, tmpdir))
136     dir = tmpdir;
137   idx = &indices[(plen == 0 && dir == tmpdir) ? 1 : 0];
138
139 #if 0
140   /* XXX Is this ever useful???  At least when using a thread package
141      which uses different PIDs for the threads it is not helpful.  */
142   if (pid != oldpid)
143     {
144       oldpid = pid;
145       indices[0] = indices[1] = 0;
146     }
147 #endif
148
149   wrapped = 0; /* We have not yet wrapped around the index counter.  */
150   len = dlen + 1 + plen + 5 + 3;
151   while (1)
152     {
153       size_t i;
154
155       if (*idx >= ((sizeof (letters) - 1) * (sizeof (letters) - 1) *
156                    (sizeof (letters) - 1)))
157         {
158           if (wrapped)
159             /* We really wrapped around this call.  Can't believe it
160                but nevertheless stop the endless loop.  */
161             break;
162
163           indices[0] = indices[1] = 0;
164           wrapped = 1;
165         }
166
167       i = (*idx)++;
168
169       /* Construct a file name and see if it already exists.
170
171          We use a single counter in *IDX to cycle each of three
172          character positions through each of 62 possible letters.  */
173
174       if (__snprintf (buf, bufsize, "%.*s/%.*s%.5d%c%c%c",
175                       (int) dlen, dir, (int) plen,
176                       pfx, pid % 100000,
177                       letters[i % (sizeof (letters) - 1)],
178                       letters[(i / (sizeof (letters) - 1))
179                              % (sizeof (letters) - 1)],
180                       letters[(i / ((sizeof (letters) - 1) *
181                                     (sizeof (letters) - 1)))
182                              % (sizeof (letters) - 1)]
183                     ) != (int) len)
184         return NULL;
185
186       if (streamptr != NULL)
187         {
188           /* Try to create the file atomically.  */
189 #ifdef _G_OPEN64
190           int fd = (large_file
191                     ? __open (buf, O_RDWR|O_CREAT|O_EXCL, 0666)
192                     : _G_OPEN64 (buf, O_RDWR|O_CREAT|O_EXCL, 0666));
193 #else
194           int fd = __open (buf, O_RDWR|O_CREAT|O_EXCL, 0666);
195 #endif
196           if (fd >= 0)
197             {
198               /* We got a new file that did not previously exist.
199                  Create a stream for it.  */
200 #ifdef USE_IN_LIBIO
201               int save;
202               struct locked_FILE
203                 {
204                   struct _IO_FILE_plus fp;
205 #ifdef _IO_MTSAFE_IO
206                   _IO_lock_t lock;
207 #endif
208                 } *new_f;
209               struct _IO_FILE_plus *fp;
210
211               new_f = (struct locked_FILE *)
212                 malloc (sizeof (struct locked_FILE));
213               if (new_f == NULL)
214                 {
215                   /* We lost trying to create a stream (out of memory?).
216                      Nothing to do but remove the file, close the descriptor,
217                      and return failure.  */
218                   save = errno;
219                 lose:
220                   (void) remove (buf);
221                   (void) __close (fd);
222                   __set_errno (save);
223                   return NULL;
224                 }
225               fp = &new_f->fp;
226 #ifdef _IO_MTSAFE_IO
227               fp->file._lock = &new_f->lock;
228 #endif
229               _IO_init (&fp->file, 0);
230               _IO_JUMPS (&fp->file) = &_IO_file_jumps;
231               _IO_file_init (&fp->file);
232 # if !_IO_UNIFIED_JUMPTABLES
233               fp->vtable = NULL;
234 # endif
235               if (_IO_file_attach (&fp->file, fd) == NULL)
236                 {
237                   save = errno;
238                   free (fp);
239                   goto lose;
240                 }
241               fp->file._flags &= ~_IO_DELETE_DONT_CLOSE;
242
243               *streamptr = (FILE *) fp;
244 #else
245               *streamptr = __newstream ();
246               if (*streamptr == NULL)
247                 {
248                   /* We lost trying to create a stream (out of memory?).
249                      Nothing to do but remove the file, close the descriptor,
250                      and return failure.  */
251                   const int save = errno;
252                   (void) remove (buf);
253                   (void) __close (fd);
254                   __set_errno (save);
255                   return NULL;
256                 }
257               (*streamptr)->__cookie = (__ptr_t) (long int) fd;
258               (*streamptr)->__mode.__write = 1;
259               (*streamptr)->__mode.__read = 1;
260               (*streamptr)->__mode.__binary = 1;
261 #endif
262             }
263 #if defined EMFILE || defined ENFILE || defined EINTR
264           else if (0
265 # ifdef EMFILE
266                    || errno == EMFILE
267 # endif
268 # ifdef ENFILE
269                    || errno == ENFILE
270 # endif
271 # ifdef EINTR
272                    || errno == EINTR
273 # endif
274                    )
275             /* We cannot open anymore files since all descriptors are
276                used or because we got a signal.  */
277             return NULL;
278 #endif
279           else
280             continue;
281         }
282       else if (exists (buf))
283         continue;
284
285       /* If the file already existed we have continued the loop above,
286          so we only get here when we have a winning name to return.  */
287
288       __set_errno (saverrno);
289
290       if (lenptr != NULL)
291         *lenptr = len + 1;
292       return buf;
293     }
294
295   /* We got out of the loop because we ran out of combinations to try.  */
296   __set_errno (EEXIST);         /* ? */
297   return NULL;
298 }