| 1 | /* provide a chdir function that tries not to fail due to ENAMETOOLONG
|
|---|
| 2 | Copyright (C) 2004-2012 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 <http://www.gnu.org/licenses/>. */
|
|---|
| 16 |
|
|---|
| 17 | /* written by Jim Meyering */
|
|---|
| 18 |
|
|---|
| 19 | #include <config.h>
|
|---|
| 20 |
|
|---|
| 21 | #include "chdir-long.h"
|
|---|
| 22 |
|
|---|
| 23 | #include <assert.h>
|
|---|
| 24 | #include <errno.h>
|
|---|
| 25 | #include <fcntl.h>
|
|---|
| 26 | #include <stdlib.h>
|
|---|
| 27 | #include <stdbool.h>
|
|---|
| 28 | #include <string.h>
|
|---|
| 29 | #include <stdio.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 inline void
|
|---|
| 46 | cdb_init (struct cd_buf *cdb)
|
|---|
| 47 | {
|
|---|
| 48 | cdb->fd = AT_FDCWD;
|
|---|
| 49 | }
|
|---|
| 50 |
|
|---|
| 51 | static inline int
|
|---|
| 52 | cdb_fchdir (struct cd_buf const *cdb)
|
|---|
| 53 | {
|
|---|
| 54 | return fchdir (cdb->fd);
|
|---|
| 55 | }
|
|---|
| 56 |
|
|---|
| 57 | static inline void
|
|---|
| 58 | cdb_free (struct cd_buf const *cdb)
|
|---|
| 59 | {
|
|---|
| 60 | if (0 <= cdb->fd)
|
|---|
| 61 | {
|
|---|
| 62 | bool close_fail = close (cdb->fd);
|
|---|
| 63 | assert (! 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 inline 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 | struct cd_buf cdb;
|
|---|
| 119 | size_t n_leading_slash;
|
|---|
| 120 |
|
|---|
| 121 | cdb_init (&cdb);
|
|---|
| 122 |
|
|---|
| 123 | /* If DIR is the empty string, then the chdir above
|
|---|
| 124 | must have failed and set errno to ENOENT. */
|
|---|
| 125 | assert (0 < len);
|
|---|
| 126 | assert (PATH_MAX <= len);
|
|---|
| 127 |
|
|---|
| 128 | /* Count leading slashes. */
|
|---|
| 129 | n_leading_slash = strspn (dir, "/");
|
|---|
| 130 |
|
|---|
| 131 | /* Handle any leading slashes as well as any name that matches
|
|---|
| 132 | the regular expression, m!^//hostname[/]*! . Handling this
|
|---|
| 133 | prefix separately usually results in a single additional
|
|---|
| 134 | cdb_advance_fd call, but it's worthwhile, since it makes the
|
|---|
| 135 | code in the following loop cleaner. */
|
|---|
| 136 | if (n_leading_slash == 2)
|
|---|
| 137 | {
|
|---|
| 138 | int err;
|
|---|
| 139 | /* Find next slash.
|
|---|
| 140 | We already know that dir[2] is neither a slash nor '\0'. */
|
|---|
| 141 | char *slash = memchr (dir + 3, '/', dir_end - (dir + 3));
|
|---|
| 142 | if (slash == NULL)
|
|---|
| 143 | {
|
|---|
| 144 | errno = ENAMETOOLONG;
|
|---|
| 145 | return -1;
|
|---|
| 146 | }
|
|---|
| 147 | *slash = '\0';
|
|---|
| 148 | err = cdb_advance_fd (&cdb, dir);
|
|---|
| 149 | *slash = '/';
|
|---|
| 150 | if (err != 0)
|
|---|
| 151 | goto Fail;
|
|---|
| 152 | dir = find_non_slash (slash + 1);
|
|---|
| 153 | }
|
|---|
| 154 | else if (n_leading_slash)
|
|---|
| 155 | {
|
|---|
| 156 | if (cdb_advance_fd (&cdb, "/") != 0)
|
|---|
| 157 | goto Fail;
|
|---|
| 158 | dir += n_leading_slash;
|
|---|
| 159 | }
|
|---|
| 160 |
|
|---|
| 161 | assert (*dir != '/');
|
|---|
| 162 | assert (dir <= dir_end);
|
|---|
| 163 |
|
|---|
| 164 | while (PATH_MAX <= dir_end - dir)
|
|---|
| 165 | {
|
|---|
| 166 | int err;
|
|---|
| 167 | /* Find a slash that is PATH_MAX or fewer bytes away from dir.
|
|---|
| 168 | I.e. see if there is a slash that will give us a name of
|
|---|
| 169 | length PATH_MAX-1 or less. */
|
|---|
| 170 | char *slash = memrchr (dir, '/', PATH_MAX);
|
|---|
| 171 | if (slash == NULL)
|
|---|
| 172 | {
|
|---|
| 173 | errno = ENAMETOOLONG;
|
|---|
| 174 | return -1;
|
|---|
| 175 | }
|
|---|
| 176 |
|
|---|
| 177 | *slash = '\0';
|
|---|
| 178 | assert (slash - dir < PATH_MAX);
|
|---|
| 179 | err = cdb_advance_fd (&cdb, dir);
|
|---|
| 180 | *slash = '/';
|
|---|
| 181 | if (err != 0)
|
|---|
| 182 | goto Fail;
|
|---|
| 183 |
|
|---|
| 184 | dir = find_non_slash (slash + 1);
|
|---|
| 185 | }
|
|---|
| 186 |
|
|---|
| 187 | if (dir < dir_end)
|
|---|
| 188 | {
|
|---|
| 189 | if (cdb_advance_fd (&cdb, dir) != 0)
|
|---|
| 190 | goto Fail;
|
|---|
| 191 | }
|
|---|
| 192 |
|
|---|
| 193 | if (cdb_fchdir (&cdb) != 0)
|
|---|
| 194 | goto Fail;
|
|---|
| 195 |
|
|---|
| 196 | cdb_free (&cdb);
|
|---|
| 197 | return 0;
|
|---|
| 198 |
|
|---|
| 199 | Fail:
|
|---|
| 200 | {
|
|---|
| 201 | int saved_errno = errno;
|
|---|
| 202 | cdb_free (&cdb);
|
|---|
| 203 | errno = saved_errno;
|
|---|
| 204 | return -1;
|
|---|
| 205 | }
|
|---|
| 206 | }
|
|---|
| 207 | }
|
|---|
| 208 |
|
|---|
| 209 | #if TEST_CHDIR
|
|---|
| 210 |
|
|---|
| 211 | # include "closeout.h"
|
|---|
| 212 | # include "error.h"
|
|---|
| 213 |
|
|---|
| 214 | char *program_name;
|
|---|
| 215 |
|
|---|
| 216 | int
|
|---|
| 217 | main (int argc, char *argv[])
|
|---|
| 218 | {
|
|---|
| 219 | char *line = NULL;
|
|---|
| 220 | size_t n = 0;
|
|---|
| 221 | int len;
|
|---|
| 222 |
|
|---|
| 223 | program_name = argv[0];
|
|---|
| 224 | atexit (close_stdout);
|
|---|
| 225 |
|
|---|
| 226 | len = getline (&line, &n, stdin);
|
|---|
| 227 | if (len < 0)
|
|---|
| 228 | {
|
|---|
| 229 | int saved_errno = errno;
|
|---|
| 230 | if (feof (stdin))
|
|---|
| 231 | exit (0);
|
|---|
| 232 |
|
|---|
| 233 | error (EXIT_FAILURE, saved_errno,
|
|---|
| 234 | "reading standard input");
|
|---|
| 235 | }
|
|---|
| 236 | else if (len == 0)
|
|---|
| 237 | exit (0);
|
|---|
| 238 |
|
|---|
| 239 | if (line[len-1] == '\n')
|
|---|
| 240 | line[len-1] = '\0';
|
|---|
| 241 |
|
|---|
| 242 | if (chdir_long (line) != 0)
|
|---|
| 243 | error (EXIT_FAILURE, errno,
|
|---|
| 244 | "chdir_long failed: %s", line);
|
|---|
| 245 |
|
|---|
| 246 | if (argc <= 1)
|
|---|
| 247 | {
|
|---|
| 248 | /* Using 'pwd' here makes sense only if it is a robust implementation,
|
|---|
| 249 | like the one in coreutils after the 2004-04-19 changes. */
|
|---|
| 250 | char const *cmd = "pwd";
|
|---|
| 251 | execlp (cmd, (char *) NULL);
|
|---|
| 252 | error (EXIT_FAILURE, errno, "%s", cmd);
|
|---|
| 253 | }
|
|---|
| 254 |
|
|---|
| 255 | fclose (stdin);
|
|---|
| 256 | fclose (stderr);
|
|---|
| 257 |
|
|---|
| 258 | exit (EXIT_SUCCESS);
|
|---|
| 259 | }
|
|---|
| 260 | #endif
|
|---|
| 261 |
|
|---|
| 262 | /*
|
|---|
| 263 | Local Variables:
|
|---|
| 264 | compile-command: "gcc -DTEST_CHDIR=1 -g -O -W -Wall chdir-long.c libcoreutils.a"
|
|---|
| 265 | End:
|
|---|
| 266 | */
|
|---|