mirror of
https://git.savannah.gnu.org/git/coreutils.git
synced 2026-11-17 18:02:09 +03:00
Renamed from chdir.c.
This commit is contained in:
1 parent
2a807da972
commit
036728c2e8
1 file changed
+342
@@ -0,0 +1,342 @@
|
||||
/* provide a chdir function that tries not to fail due to ENAMETOOLONG
|
||||
Copyright (C) 2004 Free Software Foundation, Inc.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2, or (at your option)
|
||||
any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
||||
|
||||
/* written by Jim Meyering */
|
||||
|
||||
#include <config.h>
|
||||
|
||||
#include "chdir-long.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <limits.h>
|
||||
|
||||
#include "mempcpy.h"
|
||||
#include "openat.h"
|
||||
|
||||
#ifndef O_DIRECTORY
|
||||
# define O_DIRECTORY 0
|
||||
#endif
|
||||
|
||||
#ifndef MIN
|
||||
# define MIN(a, b) ((a) < (b) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
#ifndef PATH_MAX
|
||||
# ifdef MAXPATHLEN
|
||||
# define PATH_MAX MAXPATHLEN
|
||||
# else
|
||||
# error "use this module only if your system defines PATH_MAX"
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* FIXME: this use of `MIN' is our sole concession to arbitrary limitations.
|
||||
If, for some system, PATH_MAX is larger than 8191 and you call
|
||||
chdir_long with a directory name that is longer than PATH_MAX,
|
||||
yet that contains a single component that is more than 8191 bytes
|
||||
long, then this function will fail. */
|
||||
#define MAX_COMPONENT_LENGTH MIN (PATH_MAX - 1, 8 * 1024)
|
||||
|
||||
struct cd_buf
|
||||
{
|
||||
/* FIXME maybe allocate this via malloc, rather than using the stack.
|
||||
But that would be the sole use of malloc. Is it worth it to
|
||||
let chdir_long fail due to a low-memory condition?
|
||||
But when using malloc, and assuming we remove the `concession'
|
||||
above, we'll still have to avoid allocating 2^31 bytes on
|
||||
systems that define PATH_MAX to very large number.
|
||||
Ideally, we'd allocate enough to deal with most names, and
|
||||
dynamically increase the buffer size only necessary. */
|
||||
char buffer[MAX_COMPONENT_LENGTH + 1];
|
||||
char *avail;
|
||||
int fd;
|
||||
};
|
||||
|
||||
/* Like memchr, but return the number of bytes from MEM
|
||||
to the first occurrence of C thereafter. Search only
|
||||
LEN bytes. Return LEN if C is not found. */
|
||||
static inline size_t
|
||||
memchrcspn (char const *mem, int c, size_t len)
|
||||
{
|
||||
char const *found = memchr (mem, c, len);
|
||||
if (!found)
|
||||
return len;
|
||||
|
||||
len = found - mem;
|
||||
return len;
|
||||
}
|
||||
|
||||
static void
|
||||
cdb_init (struct cd_buf *cdb)
|
||||
{
|
||||
cdb->avail = cdb->buffer;
|
||||
cdb->fd = AT_FDCWD;
|
||||
}
|
||||
|
||||
static inline bool
|
||||
cdb_empty (struct cd_buf const *cdb)
|
||||
{
|
||||
return cdb->avail == cdb->buffer;
|
||||
}
|
||||
|
||||
static inline int
|
||||
cdb_fchdir (struct cd_buf const *cdb)
|
||||
{
|
||||
return fchdir (cdb->fd);
|
||||
}
|
||||
|
||||
static int
|
||||
cdb_advance_fd (struct cd_buf *cdb, char const *dir)
|
||||
{
|
||||
int new_fd = openat (cdb->fd, dir, O_RDONLY | O_DIRECTORY);
|
||||
if (new_fd < 0)
|
||||
{
|
||||
new_fd = openat (cdb->fd, dir, O_WRONLY | O_DIRECTORY);
|
||||
if (new_fd < 0)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (cdb->fd != AT_FDCWD)
|
||||
close (cdb->fd);
|
||||
cdb->fd = new_fd;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
cdb_flush (struct cd_buf *cdb)
|
||||
{
|
||||
if (cdb_empty (cdb))
|
||||
return 0;
|
||||
|
||||
cdb->avail[0] = '\0';
|
||||
if (cdb_advance_fd (cdb, cdb->buffer) != 0)
|
||||
return -1;
|
||||
|
||||
cdb->avail = cdb->buffer;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
cdb_free (struct cd_buf *cdb)
|
||||
{
|
||||
if (0 <= cdb->fd && close (cdb->fd) != 0)
|
||||
abort ();
|
||||
}
|
||||
|
||||
static int
|
||||
cdb_append (struct cd_buf *cdb, char const *s, size_t len)
|
||||
{
|
||||
char const *end = cdb->buffer + sizeof cdb->buffer;
|
||||
|
||||
/* Insert a slash separator if there is a preceding byte
|
||||
and it's not a slash. */
|
||||
bool need_slash = (cdb->buffer < cdb->avail && cdb->avail[-1] != '/');
|
||||
size_t n_free;
|
||||
|
||||
if (sizeof cdb->buffer < len + 1)
|
||||
{
|
||||
/* This single component is too long. */
|
||||
errno = ENAMETOOLONG;
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* See if there's enough room for the `/', the new component and
|
||||
a trailing NUL. */
|
||||
n_free = end - cdb->avail;
|
||||
if (n_free < need_slash + len + 1)
|
||||
{
|
||||
if (cdb_flush (cdb) != 0)
|
||||
return -1;
|
||||
need_slash = false;
|
||||
}
|
||||
|
||||
if (need_slash)
|
||||
*(cdb->avail)++ = '/';
|
||||
|
||||
cdb->avail = mempcpy (cdb->avail, s, len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* This is a wrapper around chdir that works even on PATH_MAX-limited
|
||||
systems. It handles an arbitrarily long directory name by extracting
|
||||
and processing manageable portions of the name. On systems without
|
||||
the openat syscall, this means changing the working directory to
|
||||
more and more `distant' points along the long directory name and
|
||||
then restoring the working directory.
|
||||
If any of those attempts to change or restore the working directory
|
||||
fails, this function exits nonzero.
|
||||
|
||||
Note that this function may still fail with errno == ENAMETOOLONG,
|
||||
but only if the specified directory name contains a component that
|
||||
is long enough to provoke such a failure all by itself (e.g. if the
|
||||
component is longer than PATH_MAX on systems that define PATH_MAX). */
|
||||
|
||||
int
|
||||
chdir_long (char const *dir)
|
||||
{
|
||||
int e = chdir (dir);
|
||||
if (e == 0 || errno != ENAMETOOLONG)
|
||||
return e;
|
||||
|
||||
{
|
||||
size_t len = strlen (dir);
|
||||
char const *dir_end = dir + len;
|
||||
char const *d;
|
||||
struct cd_buf cdb;
|
||||
|
||||
cdb_init (&cdb);
|
||||
|
||||
/* If DIR is the empty string, then the chdir above
|
||||
must have failed and set errno to ENOENT. */
|
||||
assert (0 < len);
|
||||
|
||||
if (*dir == '/')
|
||||
{
|
||||
/* Names starting with exactly two slashes followed by at least
|
||||
one non-slash are special --
|
||||
for example, in some environments //Hostname/file may
|
||||
denote a file on a different host.
|
||||
Preserve those two leading slashes. Treat all other
|
||||
sequences of slashes like a single one. */
|
||||
if (3 <= len && dir[1] == '/' && dir[2] != '/')
|
||||
{
|
||||
size_t name_len = 1 + strcspn (dir + 3, "/");
|
||||
if (cdb_append (&cdb, dir, 2 + name_len) != 0)
|
||||
goto Fail;
|
||||
/* Advance D to next slash or to end of string. */
|
||||
d = dir + 2 + name_len;
|
||||
assert (*d == '/' || *d == '\0');
|
||||
}
|
||||
else
|
||||
{
|
||||
if (cdb_append (&cdb, "/", 1) != 0)
|
||||
goto Fail;
|
||||
d = dir + 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
d = dir;
|
||||
}
|
||||
|
||||
while (1)
|
||||
{
|
||||
/* Skip any slashes to find start of next component --
|
||||
or the end of DIR. */
|
||||
char const *start = d + strspn (d, "/");
|
||||
if (*start == '\0')
|
||||
{
|
||||
if (cdb_flush (&cdb) != 0)
|
||||
goto Fail;
|
||||
break;
|
||||
}
|
||||
/* If the remaining portion is no longer than PATH_MAX, then
|
||||
flush anything that is buffered and do the rest in one chunk. */
|
||||
if (dir_end - start <= PATH_MAX)
|
||||
{
|
||||
if (cdb_flush (&cdb) != 0
|
||||
|| cdb_advance_fd (&cdb, start) != 0)
|
||||
goto Fail;
|
||||
break;
|
||||
}
|
||||
|
||||
len = memchrcspn (start, '/', dir_end - start);
|
||||
assert (len == strcspn (start, "/"));
|
||||
d = start + len;
|
||||
if (cdb_append (&cdb, start, len) != 0)
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
if (cdb_fchdir (&cdb) != 0)
|
||||
goto Fail;
|
||||
|
||||
cdb_free (&cdb);
|
||||
return 0;
|
||||
|
||||
Fail:
|
||||
{
|
||||
int saved_errno = errno;
|
||||
cdb_free (&cdb);
|
||||
errno = saved_errno;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if TEST_CHDIR
|
||||
|
||||
# include <stdio.h>
|
||||
# include "closeout.h"
|
||||
# include "error.h"
|
||||
|
||||
char *program_name;
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
char *line = NULL;
|
||||
size_t n = 0;
|
||||
int len;
|
||||
|
||||
program_name = argv[0];
|
||||
atexit (close_stdout);
|
||||
|
||||
len = getline (&line, &n, stdin);
|
||||
if (len < 0)
|
||||
{
|
||||
int saved_errno = errno;
|
||||
if (feof (stdin))
|
||||
exit (0);
|
||||
|
||||
error (EXIT_FAILURE, saved_errno,
|
||||
"reading standard input");
|
||||
}
|
||||
else if (len == 0)
|
||||
exit (0);
|
||||
|
||||
if (line[len-1] == '\n')
|
||||
line[len-1] = '\0';
|
||||
|
||||
if (chdir_long (line) != 0)
|
||||
error (EXIT_FAILURE, errno,
|
||||
"chdir_long failed: %s", line);
|
||||
|
||||
{
|
||||
/* Using `pwd' here makes sense only if it is a robust implementation,
|
||||
like the one in coreutils after the 2004-04-19 changes. */
|
||||
char const *cmd = "pwd";
|
||||
execlp (cmd, (char *) NULL);
|
||||
error (EXIT_FAILURE, errno, "%s", cmd);
|
||||
}
|
||||
|
||||
/* not reached */
|
||||
abort ();
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
Local Variables:
|
||||
compile-command: "gcc -DTEST_CHDIR=1 -DHAVE_CONFIG_H -I.. -g -O -W -Wall chdir-long.c libfetish.a"
|
||||
End:
|
||||
*/
|
||||
Reference in new issue
Block a user