JehanneOS/newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* path.cc (path_conv::check): Optimize symlink replacements.

Browse Source 
* path.cc (normalize_posix_path): Add "tail" argument and set it.  Always have
a final slash for directories.  Pass 3rd argument to normalize_win32_path.
(path_conv::check): Pass tail to normalize_posix_path.  Set need_directory and
remove final slash after that call.  Remove last argument to
mount_table->conv_to_win32_path().  Remove noop dostail check.  Remove
fs.update() from inner loop.  Improve tail finding search.
(normalize_win32_path): Add and set tail argument.
(mount_item::build_win32): Avoid calling strcpy.
(mount_info::conv_to_win32_path): Remove third argument and simplify because
the source is normalized.  Keep /proc path in Posix form.  Call
win32_device_name() only once.
(mount_info::conv_to_posix_path): Add and use 3rd argument to
normalize_win32_path to avoid calling strlen.
(cwdstuff::set): Add 3rd argument to normalize_posix_path and remove final
slash if any.
* shared_info.h (mount_info::conv_to_win32_path): Remove last argument in
declaration.
This commit is contained in:
Christopher Faylor 2004-04-10 00:50:16 +00:00
parent ff0843433a
commit 60210cc795
3 changed files with 118 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
winsup/cygwin/ChangeLog
View File

@ -1,3 +1,29 @@
2004-04-05 Pierre Humblet <pierre.humblet@ieee.org>
* path.cc (path_conv::check): Optimize symlink replacements.
2004-04-09 Pierre Humblet <pierre.humblet@ieee.org>
* path.cc (normalize_posix_path): Add "tail" argument and set it.
Always have a final slash for directories. Pass 3rd argument to
normalize_win32_path.
(path_conv::check): Pass tail to normalize_posix_path. Set
need_directory and remove final slash after that call. Remove last
argument to mount_table->conv_to_win32_path(). Remove noop dostail
check. Remove fs.update() from inner loop. Improve tail finding
search.
(normalize_win32_path): Add and set tail argument.
(mount_item::build_win32): Avoid calling strcpy.
(mount_info::conv_to_win32_path): Remove third argument and simplify
because the source is normalized. Keep /proc path in Posix form. Call
win32_device_name() only once.
(mount_info::conv_to_posix_path): Add and use 3rd argument to
normalize_win32_path to avoid calling strlen.
(cwdstuff::set): Add 3rd argument to normalize_posix_path and remove
final slash if any.
* shared_info.h (mount_info::conv_to_win32_path): Remove last argument
in declaration.
2004-04-09 Corinna Vinschen <corinna@vinschen.de> 2004-04-09 Corinna Vinschen <corinna@vinschen.de>
* fhandler.h (class fhandler_dev_raw): Move status bits into protected * fhandler.h (class fhandler_dev_raw): Move status bits into protected

215
winsup/cygwin/path.cc
View File

@ -75,7 +75,7 @@ details. */
#include "cygtls.h" #include "cygtls.h"
#include <assert.h> #include <assert.h>
static int normalize_win32_path (const char *src, char *dst); static int normalize_win32_path (const char *src, char *dst, char ** tail = 0);
static void slashify (const char *src, char *dst, int trailing_slash_p); static void slashify (const char *src, char *dst, int trailing_slash_p);
static void backslashify (const char *src, char *dst, int trailing_slash_p); static void backslashify (const char *src, char *dst, int trailing_slash_p);
@ -192,7 +192,7 @@ pathmatch (const char *path1, const char *path2)
The result is 0 for success, or an errno error value. */ The result is 0 for success, or an errno error value. */
static int static int
normalize_posix_path (const char *src, char *dst) normalize_posix_path (const char *src, char *dst, char **tail)
{ {
const char *src_start = src; const char *src_start = src;
char *dst_start = dst; char *dst_start = dst;
@ -263,7 +263,6 @@ normalize_posix_path (const char *src, char *dst)
{ {
if (!src[1]) if (!src[1])
{ {
if (dst == dst_start)
*dst++ = '/'; *dst++ = '/';
goto done; goto done;
} }
@ -302,14 +301,13 @@ normalize_posix_path (const char *src, char *dst)
done: done:
*dst = '\0'; *dst = '\0';
if (--dst > dst_start && isslash (*dst)) *tail = dst;
*dst = '\0';
debug_printf ("%s = normalize_posix_path (%s)", dst_start, src_start); debug_printf ("%s = normalize_posix_path (%s)", dst_start, src_start);
return 0; return 0;
win32_path: win32_path:
int err = normalize_win32_path (in_src, in_dst); int err = normalize_win32_path (in_src, in_dst, tail);
if (!err) if (!err)
for (char *p = in_dst; (p = strchr (p, '\\')); p++) for (char *p = in_dst; (p = strchr (p, '\\')); p++)
*p = '/'; *p = '/';
@ -512,26 +510,20 @@ path_conv::check (const char *src, unsigned opt,
MALLOC_CHECK; MALLOC_CHECK;
assert (src); assert (src);
char *p = strchr (src, '\0');
/* Detect if the user was looking for a directory. We have to strip the
trailing slash initially and add it back on at the end due to Windows
brain damage. */
if (--p > src)
{
if (isdirsep (*p))
need_directory = 1;
else if (--p > src && p[1] == '.' && isdirsep (*p))
need_directory = 1;
}
is_relpath = !isabspath (src); is_relpath = !isabspath (src);
error = normalize_posix_path (src, path_copy); error = normalize_posix_path (src, path_copy, &tail);
if (error) if (error)
return; return;
tail = strchr (path_copy, '\0'); // Point to end of copy /* Detect if the user was looking for a directory. We have to strip the
trailing slash initially while trying to add extensions but take it
into account during processing */
if (tail > path_copy + 1 && isslash (*(tail - 1)))
{
need_directory = 1;
*--tail = '\0';
}
char *path_end = tail; char *path_end = tail;
tail[1] = '\0';
/* Scan path_copy from right to left looking either for a symlink /* Scan path_copy from right to left looking either for a symlink
or an actual existing file. If an existing file is found, just or an actual existing file. If an existing file is found, just
@ -542,6 +534,7 @@ path_conv::check (const char *src, unsigned opt,
int component = 0; // Number of translated components int component = 0; // Number of translated components
sym.contents[0] = '\0'; sym.contents[0] = '\0';
int symlen;
for (;;) for (;;)
{ {
const suffix_info *suff; const suffix_info *suff;
@ -565,7 +558,7 @@ path_conv::check (const char *src, unsigned opt,
/* Convert to native path spec sans symbolic link info. */ /* Convert to native path spec sans symbolic link info. */
error = mount_table->conv_to_win32_path (path_copy, full_path, dev, error = mount_table->conv_to_win32_path (path_copy, full_path, dev,
&sym.pflags, 1); &sym.pflags);
if (error) if (error)
return; return;
@ -615,19 +608,10 @@ path_conv::check (const char *src, unsigned opt,
goto out; /* Found a device. Stop parsing. */ goto out; /* Found a device. Stop parsing. */
} }
if (!fs.update (full_path))
fs.root_dir ()[0] = '\0';
/* Eat trailing slashes */
char *dostail = strchr (full_path, '\0');
/* If path is only a drivename, Windows interprets it as the /* If path is only a drivename, Windows interprets it as the
current working directory on this drive instead of the root current working directory on this drive instead of the root
dir which is what we want. So we need the trailing backslash dir which is what we want. So we need the trailing backslash
in this case. */ in this case. */
while (dostail > full_path + 3 && (*--dostail == '\\'))
*tail = '\0';
if (full_path[0] && full_path[1] == ':' && full_path[2] == '\0') if (full_path[0] && full_path[1] == ':' && full_path[2] == '\0')
{ {
full_path[2] = '\\'; full_path[2] = '\\';
@ -640,7 +624,7 @@ path_conv::check (const char *src, unsigned opt,
goto out; goto out;
} }
int len = sym.check (full_path, suff, opt | fs.sym_opt ()); symlen = sym.check (full_path, suff, opt | fs.sym_opt ());
if (sym.minor || sym.major) if (sym.minor || sym.major)
{ {
@ -691,12 +675,12 @@ path_conv::check (const char *src, unsigned opt,
done now. */ done now. */
opt |= PC_SYM_IGNORE; opt |= PC_SYM_IGNORE;
} }
/* Found a symlink if len > 0. If component == 0, then the /* Found a symlink if symlen > 0. If component == 0, then the
src path itself was a symlink. If !follow_mode then src path itself was a symlink. If !follow_mode then
we're done. Otherwise we have to insert the path found we're done. Otherwise we have to insert the path found
into the full path that we are building and perform all of into the full path that we are building and perform all of
these operations again on the newly derived path. */ these operations again on the newly derived path. */
else if (len > 0) else if (symlen > 0)
{ {
saw_symlinks = 1; saw_symlinks = 1;
if (component == 0 && !need_directory && !(opt & PC_SYM_FOLLOW)) if (component == 0 && !need_directory && !(opt & PC_SYM_FOLLOW))
@ -720,19 +704,16 @@ path_conv::check (const char *src, unsigned opt,
/* No existing file found. */ /* No existing file found. */
} }
/* Find the "tail" of the path, e.g. in '/for/bar/baz', /* Find the new "tail" of the path, e.g. in '/for/bar/baz',
/baz is the tail. */ /baz is the tail. */
char *newtail = strrchr (path_copy, '/');
if (tail != path_end) if (tail != path_end)
*tail = '/'; *tail = '/';
while (--tail > path_copy + 1 && *tail != '/') {}
/* Exit loop if there is no tail or we are at the /* Exit loop if there is no tail or we are at the
beginning of a UNC path */ beginning of a UNC path */
if (!newtail || newtail == path_copy || (newtail == path_copy + 1 && newtail[-1] == '/')) if (tail <= path_copy + 1)
goto out; // all done goto out; // all done
tail = newtail;
/* Haven't found an existing pathname component yet. /* Haven't found an existing pathname component yet.
Pinch off the tail and try again. */ Pinch off the tail and try again. */
*tail = '\0'; *tail = '\0';
@ -748,55 +729,50 @@ path_conv::check (const char *src, unsigned opt,
MALLOC_CHECK; MALLOC_CHECK;
/* The tail is pointing at a null pointer. Increment it and get the length.
If the tail was empty then this increment will end up pointing to the extra
\0 added to path_copy above. */
int taillen = strlen (++tail);
int buflen = strlen (sym.contents);
if (buflen + taillen > CYG_MAX_PATH)
{
error = ENAMETOOLONG;
strcpy (path, "::ENAMETOOLONG::");
return;
}
/* Strip off current directory component since this is the part that refers /* Place the link content, possibly with head and/or tail, in tmp_buf */
to the symbolic link. */
if ((p = strrchr (path_copy, '/')) == NULL)
p = path_copy;
else if (p == path_copy)
p++;
*p = '\0';
char *headptr; char *headptr;
if (isabspath (sym.contents)) if (isabspath (sym.contents))
headptr = tmp_buf; /* absolute path */ headptr = tmp_buf; /* absolute path */
else else
{ {
/* Copy the first part of the path and point to the end. */ /* Copy the first part of the path (with ending /) and point to the end. */
strcpy (tmp_buf, path_copy); char *prevtail = tail;
headptr = strchr (tmp_buf, '\0'); while (--prevtail > path_copy && *prevtail != '/') {}
int headlen = prevtail - path_copy + 1;;
memcpy (tmp_buf, path_copy, headlen);
headptr = &tmp_buf[headlen];
} }
/* See if we need to separate first part + symlink contents with a / */ /* Make sure there is enough space */
if (headptr > tmp_buf && headptr[-1] != '/') if (headptr + symlen >= tmp_buf + sizeof (tmp_buf))
*headptr++ = '/'; {
too_long:
error = ENAMETOOLONG;
strcpy (path, "::ENAMETOOLONG::");
return;
}
/* Copy the symlink contents to the end of tmp_buf. /* Copy the symlink contents to the end of tmp_buf.
Convert slashes. FIXME? */ Convert slashes. FIXME? I think it's fine / Pierre */
for (p = sym.contents; *p; p++) for (char *p = sym.contents; *p; p++)
*headptr++ = *p == '\\' ? '/' : *p; *headptr++ = *p == '\\' ? '/' : *p;
/* Copy any tail component */
if (tail >= path_end)
*headptr = '\0'; *headptr = '\0';
else
/* Copy any tail component (with the 0) */
if (tail++ < path_end)
{ {
/* Add a slash if needed. There is space. */
if (*(headptr - 1) != '/')
*headptr++ = '/'; *headptr++ = '/';
strcpy (headptr, tail); int taillen = path_end - tail + 1;
if (headptr + taillen > tmp_buf + sizeof (tmp_buf))
goto too_long;
memcpy (headptr, tail, taillen);
} }
/* Now evaluate everything all over again. */ /* Evaluate everything all over again. */
src = tmp_buf; src = tmp_buf;
} }
@ -804,8 +780,7 @@ path_conv::check (const char *src, unsigned opt,
add_ext_from_sym (sym); add_ext_from_sym (sym);
out: out:
/* Deal with Windows stupidity which considers filename\. to be valid /* If the user wants a directory, do not return a symlink */
even when "filename" is not a directory. */
if (!need_directory || error) if (!need_directory || error)
/* nothing to do */; /* nothing to do */;
else if (fileattr & FILE_ATTRIBUTE_DIRECTORY) else if (fileattr & FILE_ATTRIBUTE_DIRECTORY)
@ -945,7 +920,7 @@ win32_device_name (const char *src_path, char *win32_path, device& dev)
The result is 0 for success, or an errno error value. The result is 0 for success, or an errno error value.
FIXME: A lot of this should be mergeable with the POSIX critter. */ FIXME: A lot of this should be mergeable with the POSIX critter. */
static int static int
normalize_win32_path (const char *src, char *dst) normalize_win32_path (const char *src, char *dst, char **tail)
{ {
const char *src_start = src; const char *src_start = src;
char *dst_start = dst; char *dst_start = dst;
@ -1027,6 +1002,8 @@ normalize_win32_path (const char *src, char *dst)
return ENAMETOOLONG; return ENAMETOOLONG;
} }
*dst = 0; *dst = 0;
if (tail)
*tail = dst;
debug_printf ("%s = normalize_win32_path (%s)", dst_start, src_start); debug_printf ("%s = normalize_win32_path (%s)", dst_start, src_start);
return 0; return 0;
} }
@ -1356,10 +1333,7 @@ mount_item::build_win32 (char *dst, const char *src, unsigned *outflags, unsigne
if ((n + strlen (p)) > CYG_MAX_PATH) if ((n + strlen (p)) > CYG_MAX_PATH)
err = ENAMETOOLONG; err = ENAMETOOLONG;
else else
{ backslashify (p, dst + n, 0);
strcpy (dst + n, p);
backslashify (dst, dst, 0);
}
} }
else else
{ {
@ -1399,7 +1373,7 @@ mount_item::build_win32 (char *dst, const char *src, unsigned *outflags, unsigne
int int
mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev, mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev,
unsigned *flags, bool no_normalize) unsigned *flags)
{ {
bool chroot_ok = !cygheap->root.exists (); bool chroot_ok = !cygheap->root.exists ();
while (sys_mount_table_counter < cygwin_shared->sys_mount_table_counter) while (sys_mount_table_counter < cygwin_shared->sys_mount_table_counter)
@ -1407,32 +1381,17 @@ mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev,
init (); init ();
sys_mount_table_counter++; sys_mount_table_counter++;
} }
int src_path_len = strlen (src_path);
MALLOC_CHECK; MALLOC_CHECK;
unsigned dummy_flags;
dev.devn = FH_FS; dev.devn = FH_FS;
if (!flags)
flags = &dummy_flags;
*flags = 0; *flags = 0;
debug_printf ("conv_to_win32_path (%s)", src_path); debug_printf ("conv_to_win32_path (%s)", src_path);
if (src_path_len >= CYG_MAX_PATH)
{
debug_printf ("ENAMETOOLONG = conv_to_win32_path (%s)", src_path);
return ENAMETOOLONG;
}
int i, rc; int i, rc;
mount_item *mi = NULL; /* initialized to avoid compiler warning */ mount_item *mi = NULL; /* initialized to avoid compiler warning */
char pathbuf[CYG_MAX_PATH];
if (dst == NULL) /* The path is already normalized, without ../../ stuff, we need to have this
goto out; /* Sanity check. */
/* Normalize the path, taking out ../../ stuff, we need to do this
so that we can move from one mounted directory to another with relative so that we can move from one mounted directory to another with relative
stuff. stuff.
@ -1444,25 +1403,11 @@ mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev,
should look in c:/foo, not d:/foo. should look in c:/foo, not d:/foo.
We do this by first getting an absolute UNIX-style path and then converting normalizex UNIX path to a DOS-style path, looking up the
converting it to a DOS-style path, looking up the appropriate drive appropriate drive in the mount table. */
in the mount table. */
if (no_normalize)
strcpy (pathbuf, src_path);
else
{
rc = normalize_posix_path (src_path, pathbuf);
if (rc)
{
debug_printf ("%d = conv_to_win32_path (%s)", rc, src_path);
return rc;
}
}
/* See if this is a cygwin "device" */ /* See if this is a cygwin "device" */
if (win32_device_name (pathbuf, dst, dev)) if (win32_device_name (src_path, dst, dev))
{ {
*flags = MOUNT_BINARY; /* FIXME: Is this a sensible default for devices? */ *flags = MOUNT_BINARY; /* FIXME: Is this a sensible default for devices? */
rc = 0; rc = 0;
@ -1472,27 +1417,30 @@ mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev,
/* Check if the cygdrive prefix was specified. If so, just strip /* Check if the cygdrive prefix was specified. If so, just strip
off the prefix and transform it into an MS-DOS path. */ off the prefix and transform it into an MS-DOS path. */
MALLOC_CHECK; MALLOC_CHECK;
if (isproc (pathbuf)) if (isproc (src_path))
{ {
dev = *proc_dev; dev = *proc_dev;
dev.devn = fhandler_proc::get_proc_fhandler (pathbuf); dev.devn = fhandler_proc::get_proc_fhandler (src_path);
if (dev.devn == FH_BAD) if (dev.devn == FH_BAD)
return ENOENT; return ENOENT;
set_flags (flags, PATH_BINARY);
strcpy (dst, src_path);
goto out;
} }
else if (iscygdrive (pathbuf)) else if (iscygdrive (src_path))
{ {
int n = mount_table->cygdrive_len - 1; int n = mount_table->cygdrive_len - 1;
int unit; int unit;
if (!pathbuf[n] || if (!src_path[n] ||
(pathbuf[n] == '/' && pathbuf[n + 1] == '.' && !pathbuf[n + 2])) (src_path[n] == '/' && src_path[n + 1] == '.' && !src_path[n + 2]))
{ {
unit = 0; unit = 0;
dst[0] = '\0'; dst[0] = '\0';
if (mount_table->cygdrive_len > 1) if (mount_table->cygdrive_len > 1)
dev = *cygdrive_dev; dev = *cygdrive_dev;
} }
else if (cygdrive_win32_path (pathbuf, dst, unit)) else if (cygdrive_win32_path (src_path, dst, unit))
{ {
set_flags (flags, (unsigned) cygdrive_flags); set_flags (flags, (unsigned) cygdrive_flags);
goto out; goto out;
@ -1527,31 +1475,23 @@ mount_info::conv_to_win32_path (const char *src_path, char *dst, device& dev,
continue; continue;
} }
if (path_prefix_p (path, pathbuf, len)) if (path_prefix_p (path, src_path, len))
break; break;
} }
if (i < nmounts) if (i < nmounts)
{ {
int err = mi->build_win32 (dst, pathbuf, flags, chroot_pathlen); int err = mi->build_win32 (dst, src_path, flags, chroot_pathlen);
if (err) if (err)
return err; return err;
chroot_ok = true; chroot_ok = true;
} }
else else
{ {
if (strpbrk (src_path, ":\\") != NULL || slash_unc_prefix_p (src_path)) if (strchr (src_path, ':') == NULL && !slash_unc_prefix_p (src_path))
rc = normalize_win32_path (src_path, dst);
else
{
backslashify (pathbuf, dst, 0); /* just convert */
set_flags (flags, PATH_BINARY); set_flags (flags, PATH_BINARY);
backslashify (src_path, dst, 0);
} }
chroot_ok = !cygheap->root.exists ();
}
if (!isvirtual_dev (dev.devn))
win32_device_name (src_path, dst, dev);
out: out:
MALLOC_CHECK; MALLOC_CHECK;
@ -1667,14 +1607,15 @@ mount_info::conv_to_posix_path (const char *src_path, char *posix_path,
} }
char pathbuf[CYG_MAX_PATH]; char pathbuf[CYG_MAX_PATH];
int rc = normalize_win32_path (src_path, pathbuf); char * tail;
int rc = normalize_win32_path (src_path, pathbuf, &tail);
if (rc != 0) if (rc != 0)
{ {
debug_printf ("%d = conv_to_posix_path (%s)", rc, src_path); debug_printf ("%d = conv_to_posix_path (%s)", rc, src_path);
return rc; return rc;
} }
int pathbuflen = strlen (pathbuf); int pathbuflen = tail - pathbuf;
for (int i = 0; i < nmounts; ++i) for (int i = 0; i < nmounts; ++i)
{ {
mount_item &mi = mount[native_sorted[i]]; mount_item &mi = mount[native_sorted[i]];
@ -3769,8 +3710,12 @@ cwdstuff::set (const char *win32_cwd, const char *posix_cwd)
if (!posix_cwd) if (!posix_cwd)
mount_table->conv_to_posix_path (win32, pathbuf, 0); mount_table->conv_to_posix_path (win32, pathbuf, 0);
else else
(void) normalize_posix_path (posix_cwd, pathbuf); {
char * tail;
(void) normalize_posix_path (posix_cwd, pathbuf, &tail);
if (tail > pathbuf + 1 && *(--tail) == '/')
*tail = 0;
}
posix = (char *) crealloc (posix, strlen (pathbuf) + 1); posix = (char *) crealloc (posix, strlen (pathbuf) + 1);
strcpy (posix, pathbuf); strcpy (posix, pathbuf);

2
winsup/cygwin/shared_info.h
View File

@ -85,7 +85,7 @@ class mount_info
unsigned set_flags_from_win32_path (const char *path); unsigned set_flags_from_win32_path (const char *path);
int conv_to_win32_path (const char *src_path, char *dst, device&, int conv_to_win32_path (const char *src_path, char *dst, device&,
unsigned *flags = NULL, bool no_normalize = 0); unsigned *flags = NULL);
int conv_to_posix_path (const char *src_path, char *posix_path, int conv_to_posix_path (const char *src_path, char *posix_path,
int keep_rel_p); int keep_rel_p);
struct mntent *getmntent (int x); struct mntent *getmntent (int x);