Debian Codegraph @

lib/chdir-long.c

raw
1 /* provide a chdir function that tries not to fail due to ENAMETOOLONG
2 Copyright (C) 2004-2026 Free Software Foundation, Inc.
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
8
9 This program 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 General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
16
17 /* written by Jim Meyering */
18
19 #include <config.h>
20
21 #include "chdir-long.h"
22
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <stdio.h>
28
29 #include "assure.h"
30
31 #ifndef PATH_MAX
32 # error "compile this file only if your system defines PATH_MAX"
33 #endif
34
35 /* The results of openat() in this file are not leaked to any
36 single-threaded code that could use stdio.
37 FIXME - if the kernel ever adds support for multi-thread safety for
38 avoiding standard fds, then we should use openat_safer. */
39
40 struct cd_buf
41 {
42 int fd;
43 };
44
45 static void
46 cdb_init (struct cd_buf *cdb)
47 {
48 cdb->fd = AT_FDCWD;
49 }
50
51 static int
52 cdb_fchdir (struct cd_buf const *cdb)
53 {
54 return fchdir (cdb->fd);
55 }
56
57 static void
58 cdb_free (struct cd_buf const *cdb)
59 {
60 if (0 <= cdb->fd)
61 {
62 bool close_fail = close (cdb->fd);
63 assure (! close_fail);
64 }
65 }
66
67 /* Given a file descriptor of an open directory (or AT_FDCWD), CDB->fd,
68 try to open the CDB->fd-relative directory, DIR. If the open succeeds,
69 update CDB->fd with the resulting descriptor, close the incoming file
70 descriptor, and return zero. Upon failure, return -1 and set errno. */
71 static int
72 cdb_advance_fd (struct cd_buf *cdb, char const *dir)
73 {
74 int new_fd = openat (cdb->fd, dir,
75 O_SEARCH | O_DIRECTORY | O_NOCTTY | O_NONBLOCK);
76 if (new_fd < 0)
77 return -1;
78
79 cdb_free (cdb);
80 cdb->fd = new_fd;
81
82 return 0;
83 }
84
85 /* Return a pointer to the first non-slash in S. */
86 static char * _GL_ATTRIBUTE_PURE
87 find_non_slash (char const *s)
88 {
89 size_t n_slash = strspn (s, "/");
90 return (char *) s + n_slash;
91 }
92
93 /* This is a function much like chdir, but without the PATH_MAX limitation
94 on the length of the directory name. A significant difference is that
95 it must be able to modify (albeit only temporarily) the directory
96 name. It handles an arbitrarily long directory name by operating
97 on manageable portions of the name. On systems without the openat
98 syscall, this means changing the working directory to more and more
99 "distant" points along the long directory name and then restoring
100 the working directory. If any of those attempts to save or restore
101 the working directory fails, this function exits nonzero.
102
103 Note that this function may still fail with errno == ENAMETOOLONG, but
104 only if the specified directory name contains a component that is long
105 enough to provoke such a failure all by itself (e.g. if the component
106 has length PATH_MAX or greater on systems that define PATH_MAX). */
107
108 int
109 chdir_long (char *dir)
110 {
111 int e = chdir (dir);
112 if (e == 0 || errno != ENAMETOOLONG)
113 return e;
114
115 {
116 size_t len = strlen (dir);
117 char *dir_end = dir + len;
118
119 struct cd_buf cdb;
120 cdb_init (&cdb);
121
122 /* If DIR is the empty string, then the chdir above
123 must have failed and set errno to ENOENT. */
124 assure (0 < len);
125 assure (PATH_MAX <= len);
126
127 /* Count leading slashes. */
128 size_t n_leading_slash = strspn (dir, "/");
129
130 /* Handle any leading slashes as well as any name that matches
131 the regular expression, m!^//hostname[/]*! . Handling this
132 prefix separately usually results in a single additional
133 cdb_advance_fd call, but it's worthwhile, since it makes the
134 code in the following loop cleaner. */
135 if (n_leading_slash == 2)
136 {
137 /* Find next slash.
138 We already know that dir[2] is neither a slash nor '\0'. */
139 char *slash = memchr (dir + 3, '/', dir_end - (dir + 3));
140 if (slash == NULL)
141 {
142 errno = ENAMETOOLONG;
143 return -1;
144 }
145 *slash = '\0';
146 int err = cdb_advance_fd (&cdb, dir);
147 *slash = '/';
148 if (err != 0)
149 goto Fail;
150 dir = find_non_slash (slash + 1);
151 }
152 else if (n_leading_slash)
153 {
154 if (cdb_advance_fd (&cdb, "/") != 0)
155 goto Fail;
156 dir += n_leading_slash;
157 }
158
159 assure (*dir != '/');
160 assure (dir <= dir_end);
161
162 while (PATH_MAX <= dir_end - dir)
163 {
164 /* Find a slash that is PATH_MAX or fewer bytes away from dir.
165 I.e. see if there is a slash that will give us a name of
166 length PATH_MAX-1 or less. */
167 char *slash = memrchr (dir, '/', PATH_MAX);
168 if (slash == NULL)
169 {
170 errno = ENAMETOOLONG;
171 return -1;
172 }
173
174 *slash = '\0';
175 assure (slash - dir < PATH_MAX);
176 int err = cdb_advance_fd (&cdb, dir);
177 *slash = '/';
178 if (err != 0)
179 goto Fail;
180
181 dir = find_non_slash (slash + 1);
182 }
183
184 if (dir < dir_end)
185 {
186 if (cdb_advance_fd (&cdb, dir) != 0)
187 goto Fail;
188 }
189
190 if (cdb_fchdir (&cdb) != 0)
191 goto Fail;
192
193 cdb_free (&cdb);
194 return 0;
195
196 Fail:
197 {
198 int saved_errno = errno;
199 cdb_free (&cdb);
200 errno = saved_errno;
201 return -1;
202 }
203 }
204 }
205
206 #if TEST_CHDIR
207
208 # include "closeout.h"
209 # include <error.h>
210
211 int
212 main (int argc, char *argv[])
213 {
214 atexit (close_stdout);
215
216 char *line = NULL;
217 size_t n = 0;
218 int len = getline (&line, &n, stdin);
219 if (len < 0)
220 {
221 int saved_errno = errno;
222 if (feof (stdin))
223 exit (0);
224
225 error (EXIT_FAILURE, saved_errno,
226 "reading standard input");
227 }
228 else if (len == 0)
229 exit (0);
230
231 if (line[len-1] == '\n')
232 line[len-1] = '\0';
233
234 if (chdir_long (line) != 0)
235 error (EXIT_FAILURE, errno,
236 "chdir_long failed: %s", line);
237
238 if (argc <= 1)
239 {
240 /* Using 'pwd' here makes sense only if it is a robust implementation,
241 like the one in coreutils after the 2004-04-19 changes. */
242 char const *cmd = "pwd";
243 execlp (cmd, (char *) NULL);
244 error (EXIT_FAILURE, errno, "%s", cmd);
245 }
246
247 fclose (stdin);
248 fclose (stderr);
249
250 exit (EXIT_SUCCESS);
251 }
252 #endif
253
254 /*
255 Local Variables:
256 compile-command: "gcc -DTEST_CHDIR=1 -g -O -W -Wall chdir-long.c libcoreutils.a"
257 End:
258 */