1/* provide a chdir function that tries not to fail due to ENAMETOOLONG 2 Copyright (C) 2004, 2005, 2006, 2007 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 <fcntl.h> 24#include <stdlib.h> 25#include <stdbool.h> 26#include <string.h> 27#include <errno.h> 28#include <stdio.h> 29#include <assert.h> 30 31#include "openat.h" 32 33#ifndef PATH_MAX 34# error "compile this file only if your system defines PATH_MAX" 35#endif 36 37struct cd_buf 38{ 39 int fd; 40}; 41 42static inline void 43cdb_init (struct cd_buf *cdb) 44{ 45 cdb->fd = AT_FDCWD; 46} 47 48static inline int 49cdb_fchdir (struct cd_buf const *cdb) 50{ 51 return fchdir (cdb->fd); 52} 53 54static inline void 55cdb_free (struct cd_buf const *cdb) 56{ 57 if (0 <= cdb->fd) 58 { 59 bool close_fail = close (cdb->fd); 60 assert (! close_fail); 61 } 62} 63 64/* Given a file descriptor of an open directory (or AT_FDCWD), CDB->fd, 65 try to open the CDB->fd-relative directory, DIR. If the open succeeds, 66 update CDB->fd with the resulting descriptor, close the incoming file 67 descriptor, and return zero. Upon failure, return -1 and set errno. */ 68static int 69cdb_advance_fd (struct cd_buf *cdb, char const *dir) 70{ 71 int new_fd = openat (cdb->fd, dir, 72 O_RDONLY | O_DIRECTORY | O_NOCTTY | O_NONBLOCK); 73 if (new_fd < 0) 74 return -1; 75 76 cdb_free (cdb); 77 cdb->fd = new_fd; 78 79 return 0; 80} 81 82/* Return a pointer to the first non-slash in S. */ 83static inline char * 84find_non_slash (char const *s) 85{ 86 size_t n_slash = strspn (s, "/"); 87 return (char *) s + n_slash; 88} 89 90/* This is a function much like chdir, but without the PATH_MAX limitation 91 on the length of the directory name. A significant difference is that 92 it must be able to modify (albeit only temporarily) the directory 93 name. It handles an arbitrarily long directory name by operating 94 on manageable portions of the name. On systems without the openat 95 syscall, this means changing the working directory to more and more 96 `distant' points along the long directory name and then restoring 97 the working directory. If any of those attempts to save or restore 98 the working directory fails, this function exits nonzero. 99 100 Note that this function may still fail with errno == ENAMETOOLONG, but 101 only if the specified directory name contains a component that is long 102 enough to provoke such a failure all by itself (e.g. if the component 103 has length PATH_MAX or greater on systems that define PATH_MAX). */ 104 105int 106chdir_long (char *dir) 107{ 108 int e = chdir (dir); 109 if (e == 0 || errno != ENAMETOOLONG) 110 return e; 111 112 { 113 size_t len = strlen (dir); 114 char *dir_end = dir + len; 115 struct cd_buf cdb; 116 size_t n_leading_slash; 117 118 cdb_init (&cdb); 119 120 /* If DIR is the empty string, then the chdir above 121 must have failed and set errno to ENOENT. */ 122 assert (0 < len); 123 assert (PATH_MAX <= len); 124 125 /* Count leading slashes. */ 126 n_leading_slash = strspn (dir, "/"); 127 128 /* Handle any leading slashes as well as any name that matches 129 the regular expression, m!^//hostname[/]*! . Handling this 130 prefix separately usually results in a single additional 131 cdb_advance_fd call, but it's worthwhile, since it makes the 132 code in the following loop cleaner. */ 133 if (n_leading_slash == 2) 134 { 135 int err; 136 /* Find next slash. 137 We already know that dir[2] is neither a slash nor '\0'. */ 138 char *slash = memchr (dir + 3, '/', dir_end - (dir + 3)); 139 if (slash == NULL) 140 { 141 errno = ENAMETOOLONG; 142 return -1; 143 } 144 *slash = '\0'; 145 err = cdb_advance_fd (&cdb, dir); 146 *slash = '/'; 147 if (err != 0) 148 goto Fail; 149 dir = find_non_slash (slash + 1); 150 } 151 else if (n_leading_slash) 152 { 153 if (cdb_advance_fd (&cdb, "/") != 0) 154 goto Fail; 155 dir += n_leading_slash; 156 } 157 158 assert (*dir != '/'); 159 assert (dir <= dir_end); 160 161 while (PATH_MAX <= dir_end - dir) 162 { 163 int err; 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 assert (slash - dir < PATH_MAX); 176 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 <stdio.h> 209# include "closeout.h" 210# include "error.h" 211 212char *program_name; 213 214int 215main (int argc, char *argv[]) 216{ 217 char *line = NULL; 218 size_t n = 0; 219 int len; 220 221 program_name = argv[0]; 222 atexit (close_stdout); 223 224 len = getline (&line, &n, stdin); 225 if (len < 0) 226 { 227 int saved_errno = errno; 228 if (feof (stdin)) 229 exit (0); 230 231 error (EXIT_FAILURE, saved_errno, 232 "reading standard input"); 233 } 234 else if (len == 0) 235 exit (0); 236 237 if (line[len-1] == '\n') 238 line[len-1] = '\0'; 239 240 if (chdir_long (line) != 0) 241 error (EXIT_FAILURE, errno, 242 "chdir_long failed: %s", line); 243 244 if (argc <= 1) 245 { 246 /* Using `pwd' here makes sense only if it is a robust implementation, 247 like the one in coreutils after the 2004-04-19 changes. */ 248 char const *cmd = "pwd"; 249 execlp (cmd, (char *) NULL); 250 error (EXIT_FAILURE, errno, "%s", cmd); 251 } 252 253 fclose (stdin); 254 fclose (stderr); 255 256 exit (EXIT_SUCCESS); 257} 258#endif 259 260/* 261Local Variables: 262compile-command: "gcc -DTEST_CHDIR=1 -g -O -W -Wall chdir-long.c libcoreutils.a" 263End: 264*/ 265