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