1/* provide a chdir function that tries not to fail due to ENAMETOOLONG
2   Copyright (C) 2004-2010 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
40struct cd_buf
41{
42  int fd;
43};
44
45static inline void
46cdb_init (struct cd_buf *cdb)
47{
48  cdb->fd = AT_FDCWD;
49}
50
51static inline int
52cdb_fchdir (struct cd_buf const *cdb)
53{
54  return fchdir (cdb->fd);
55}
56
57static inline void
58cdb_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.  */
71static int
72cdb_advance_fd (struct cd_buf *cdb, char const *dir)
73{
74  int new_fd = openat (cdb->fd, dir,
75                       O_RDONLY | 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.  */
86static inline char *
87find_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
108int
109chdir_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
214char *program_name;
215
216int
217main (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/*
263Local Variables:
264compile-command: "gcc -DTEST_CHDIR=1 -g -O -W -Wall chdir-long.c libcoreutils.a"
265End:
266*/
267