Debian Codegraph @

lib/fchdir.c

raw
1 /* fchdir replacement.
2 Copyright (C) 2006-2026 Free Software Foundation, Inc.
3
4 This file is free software: you can redistribute it and/or modify
5 it under the terms of the GNU Lesser General Public License as
6 published by the Free Software Foundation, either version 3 of the
7 License, or (at your option) any later version.
8
9 This file 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
12 GNU Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 /* Specification. */
20 #include <unistd.h>
21
22 #include <dirent.h>
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29
30 #include "assure.h"
31 #include "filename.h"
32 #include "filenamecat.h"
33
34 #ifndef REPLACE_OPEN_DIRECTORY
35 # define REPLACE_OPEN_DIRECTORY 0
36 #endif
37
38 /* This replacement assumes that a directory is not renamed while opened
39 through a file descriptor.
40
41 FIXME: On mingw, this would be possible to enforce if we were to
42 also open a HANDLE to each directory currently visited by a file
43 descriptor, since mingw refuses to rename any in-use file system
44 object. */
45
46 /* Array of file descriptors opened. If REPLACE_OPEN_DIRECTORY or if it points
47 to a directory, it stores info about this directory. */
48 typedef struct
49 {
50 char *name; /* Absolute name of the directory, or NULL. */
51 } dir_info_t;
52 static dir_info_t *dirs;
53 static size_t dirs_allocated;
54
55 /* Try to ensure dirs has enough room for a slot at index fd; free any
56 contents already in that slot. Return false and set errno to
57 ENOMEM on allocation failure. */
58 static bool
59 ensure_dirs_slot (size_t fd)
60 {
61 if (fd < dirs_allocated)
62 free (dirs[fd].name);
63 else
64 {
65 size_t new_allocated = 2 * dirs_allocated + 1;
66 if (new_allocated <= fd)
67 new_allocated = fd + 1;
68 dir_info_t *new_dirs =
69 (dirs != NULL
70 ? (dir_info_t *) realloc (dirs, new_allocated * sizeof *dirs)
71 : (dir_info_t *) malloc (new_allocated * sizeof *dirs));
72 if (new_dirs == NULL)
73 return false;
74 memset (new_dirs + dirs_allocated, 0,
75 (new_allocated - dirs_allocated) * sizeof *dirs);
76 dirs = new_dirs;
77 dirs_allocated = new_allocated;
78 }
79 return true;
80 }
81
82 /* Return an absolute name of DIR in malloc'd storage.
83 Upon failure, return NULL with errno set. */
84 static char *
85 get_name (char const *dir)
86 {
87 if (IS_ABSOLUTE_FILE_NAME (dir))
88 return strdup (dir);
89
90 /* We often encounter "."; treat it as a special case. */
91 char *cwd = getcwd (NULL, 0);
92 if (!cwd || (dir[0] == '.' && dir[1] == '\0'))
93 return cwd;
94
95 char *result = mfile_name_concat (cwd, dir, NULL);
96 free (cwd);
97 return result;
98 }
99
100 /* Hook into the gnulib replacements for open() and close() to keep track
101 of the open file descriptors. */
102
103 /* Close FD, cleaning up any fd to name mapping if fd was visiting a
104 directory. */
105 void
106 _gl_unregister_fd (int fd)
107 {
108 if (fd >= 0 && fd < dirs_allocated)
109 {
110 free (dirs[fd].name);
111 dirs[fd].name = NULL;
112 }
113 }
114
115 /* Mark FD as visiting FILENAME. FD must be non-negative, and refer
116 to an open file descriptor. If REPLACE_OPEN_DIRECTORY is non-zero,
117 this should only be called if FD is visiting a directory. Close FD
118 and return -1 with errno set if there is insufficient memory to track
119 the directory name; otherwise return FD. */
120 int
121 _gl_register_fd (int fd, const char *filename)
122 {
123 assure (0 <= fd);
124
125 struct stat statbuf;
126 if (REPLACE_OPEN_DIRECTORY
127 || (fstat (fd, &statbuf) == 0 && S_ISDIR (statbuf.st_mode)))
128 {
129 if (!ensure_dirs_slot (fd)
130 || (dirs[fd].name = get_name (filename)) == NULL)
131 {
132 int saved_errno = errno;
133 close (fd);
134 errno = saved_errno;
135 return -1;
136 }
137 }
138 return fd;
139 }
140
141 /* Mark NEWFD as a duplicate of OLDFD; useful from dup, dup2, dup3,
142 and fcntl. Both arguments must be valid and distinct file
143 descriptors. Close NEWFD and return -1 if OLDFD is tracking a
144 directory, but there is insufficient memory to track the same
145 directory in NEWFD; otherwise return NEWFD. */
146 int
147 _gl_register_dup (int oldfd, int newfd)
148 {
149 assure (0 <= oldfd && 0 <= newfd && oldfd != newfd);
150 if (oldfd < dirs_allocated && dirs[oldfd].name)
151 {
152 /* Duplicated a directory; must ensure newfd is allocated. */
153 if (!ensure_dirs_slot (newfd)
154 || (dirs[newfd].name = strdup (dirs[oldfd].name)) == NULL)
155 {
156 int saved_errno = errno;
157 close (newfd);
158 errno = saved_errno;
159 newfd = -1;
160 }
161 }
162 else if (newfd < dirs_allocated)
163 {
164 /* Duplicated a non-directory; ensure newfd is cleared. */
165 free (dirs[newfd].name);
166 dirs[newfd].name = NULL;
167 }
168 return newfd;
169 }
170
171 /* If FD is currently visiting a directory, then return the name of
172 that directory. Otherwise, return NULL and set errno. */
173 const char *
174 _gl_directory_name (int fd)
175 {
176 if (0 <= fd && fd < dirs_allocated && dirs[fd].name != NULL)
177 return dirs[fd].name;
178 /* At this point, fd is either invalid, or open but not a directory.
179 If dup2 fails, errno is correctly EBADF. */
180 if (0 <= fd)
181 {
182 if (dup2 (fd, fd) == fd)
183 errno = ENOTDIR;
184 }
185 else
186 errno = EBADF;
187 return NULL;
188 }
189
190
191 /* Implement fchdir() in terms of chdir(). */
192
193 int
194 fchdir (int fd)
195 {
196 const char *name = _gl_directory_name (fd);
197 return name ? chdir (name) : -1;
198 }