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