mirror of https://github.com/moparisthebest/wget
[svn] Rewrite path_simplify.
Published in <sxspu5nx2yi.fsf@florida.arsdigita.de>.
This commit is contained in:
hniksic
parent
233fcbc44d
commit
0e72aa6e13
|
|
@ -1,3 +1,8 @@
|
||||||
|
2001-12-10 Hrvoje Niksic <hniksic@arsdigita.com>
|
||||||
|
|
||||||
|
* utils.c (path_simplify): Rewrite, with better comments, and
|
||||||
|
without the use of strcpy to move overlapping blocks.
|
||||||
|
|
||||||
2001-12-09 Hrvoje Niksic <hniksic@arsdigita.com>
|
2001-12-09 Hrvoje Niksic <hniksic@arsdigita.com>
|
||||||
|
|
||||||
* init.c (cmd_spec_progress): Resurrect. Check whether VAL is a
|
* init.c (cmd_spec_progress): Resurrect. Check whether VAL is a
|
||||||
|
|
|
||||||
317
src/utils.c
317
src/utils.c
|
|
@ -473,163 +473,125 @@ fork_to_background (void)
|
||||||
}
|
}
|
||||||
#endif /* not WINDOWS */
|
#endif /* not WINDOWS */
|
||||||
|
|
||||||
#if 0
|
/* Resolve "." and ".." elements of PATH by destructively modifying
|
||||||
/* debug */
|
PATH. "." is resolved by removing that path element, and ".." is
|
||||||
char *
|
resolved by removing the preceding path element. Leading and
|
||||||
ps (char *orig)
|
trailing slashes are preserved.
|
||||||
{
|
|
||||||
char *r = xstrdup (orig);
|
|
||||||
path_simplify (r);
|
|
||||||
return r;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Canonicalize PATH, and return a new path. The new path differs from PATH
|
Return non-zero if any changes have been made.
|
||||||
in that:
|
|
||||||
Multple `/'s are collapsed to a single `/'.
|
|
||||||
Leading `./'s and trailing `/.'s are removed.
|
|
||||||
Trailing `/'s are removed.
|
|
||||||
Non-leading `../'s and trailing `..'s are handled by removing
|
|
||||||
portions of the path.
|
|
||||||
|
|
||||||
E.g. "a/b/c/./../d/.." will yield "a/b/". This function originates
|
For example, "a/b/c/./../d/.." will yield "a/b/". More exhaustive
|
||||||
from GNU Bash and has been mutilated to unrecognition for use in
|
test examples are provided below. If you change anything in this
|
||||||
Wget.
|
function, run test_path_simplify to make sure you haven't broken a
|
||||||
|
test case.
|
||||||
|
|
||||||
Changes for Wget:
|
A previous version of this function was based on path_simplify()
|
||||||
Always use '/' as stub_char.
|
from GNU Bash, but it has been rewritten for Wget 1.8.1. */
|
||||||
Don't check for local things using canon_stat.
|
|
||||||
Change the original string instead of strdup-ing.
|
|
||||||
React correctly when beginning with `./' and `../'.
|
|
||||||
Don't zip out trailing slashes.
|
|
||||||
Return a value indicating whether any modifications took place.
|
|
||||||
|
|
||||||
If you dare change this function, take a careful look at the test
|
|
||||||
cases below, and make sure that they pass. */
|
|
||||||
|
|
||||||
int
|
int
|
||||||
path_simplify (char *path)
|
path_simplify (char *path)
|
||||||
{
|
{
|
||||||
register int i, start;
|
int change = 0;
|
||||||
int changes = 0;
|
char *p, *end;
|
||||||
|
|
||||||
if (!*path)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
if (path[0] == '/')
|
if (path[0] == '/')
|
||||||
/* Preserve initial '/'. */
|
++path; /* preserve the leading '/'. */
|
||||||
++path;
|
|
||||||
|
|
||||||
/* Nix out leading `.' or `..' with. */
|
p = path;
|
||||||
if ((path[0] == '.' && path[1] == '\0')
|
end = p + strlen (p) + 1; /* position past the terminating zero. */
|
||||||
|| (path[0] == '.' && path[1] == '.' && path[2] == '\0'))
|
|
||||||
{
|
|
||||||
path[0] = '\0';
|
|
||||||
changes = 1;
|
|
||||||
return changes;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Walk along PATH looking for things to compact. */
|
|
||||||
i = 0;
|
|
||||||
while (1)
|
while (1)
|
||||||
{
|
{
|
||||||
if (!path[i])
|
again:
|
||||||
break;
|
/* P should point to the beginning of a path element. */
|
||||||
|
|
||||||
while (path[i] && path[i] != '/')
|
if (*p == '.' && (*(p + 1) == '/' || *(p + 1) == '\0'))
|
||||||
i++;
|
|
||||||
|
|
||||||
start = i++;
|
|
||||||
|
|
||||||
/* If we didn't find any slashes, then there is nothing left to do. */
|
|
||||||
if (!path[start])
|
|
||||||
break;
|
|
||||||
|
|
||||||
/* Handle multiple `/'s in a row. */
|
|
||||||
while (path[i] == '/')
|
|
||||||
i++;
|
|
||||||
|
|
||||||
if ((start + 1) != i)
|
|
||||||
{
|
{
|
||||||
strcpy (path + start + 1, path + i);
|
/* Handle "./foo" by moving "foo" two characters to the
|
||||||
i = start + 1;
|
left. */
|
||||||
changes = 1;
|
if (*(p + 1) == '/')
|
||||||
}
|
|
||||||
|
|
||||||
/* Check for `../', `./' or trailing `.' by itself. */
|
|
||||||
if (path[i] == '.')
|
|
||||||
{
|
|
||||||
/* Handle trailing `.' by itself. */
|
|
||||||
if (!path[i + 1])
|
|
||||||
{
|
{
|
||||||
path[--i] = '\0';
|
change = 1;
|
||||||
changes = 1;
|
memmove (p, p + 2, end - p);
|
||||||
|
end -= 2;
|
||||||
|
goto again;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
change = 1;
|
||||||
|
*p = '\0';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (*p == '.' && *(p + 1) == '.'
|
||||||
|
&& (*(p + 2) == '/' || *(p + 2) == '\0'))
|
||||||
|
{
|
||||||
|
/* Handle "../foo" by moving "foo" one path element to the
|
||||||
|
left. */
|
||||||
|
char *b = p;
|
||||||
|
|
||||||
|
/* Backtrack by one path element, but not past the beginning
|
||||||
|
of PATH. */
|
||||||
|
|
||||||
|
/* foo/bar/../baz */
|
||||||
|
/* ^ p */
|
||||||
|
/* ^ b */
|
||||||
|
|
||||||
|
if (b > path + 1)
|
||||||
|
{
|
||||||
|
/* Find the character preceded by slash or by the
|
||||||
|
beginning of path. */
|
||||||
|
for (--b; b > path && *(b - 1) != '/'; b--)
|
||||||
|
;
|
||||||
|
}
|
||||||
|
|
||||||
|
change = 1;
|
||||||
|
if (*(p + 2) == '/')
|
||||||
|
{
|
||||||
|
memmove (b, p + 3, end - (p + 3));
|
||||||
|
end -= (p + 3) - b;
|
||||||
|
p = b;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
*b = '\0';
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Handle `./'. */
|
goto again;
|
||||||
if (path[i + 1] == '/')
|
}
|
||||||
|
else if (*p == '/')
|
||||||
|
{
|
||||||
|
/* Remove empty path elements. Not mandated by rfc1808 et
|
||||||
|
al, but empty path elements are not all that useful, and
|
||||||
|
the rest of Wget might not deal with them well. */
|
||||||
|
char *q = p;
|
||||||
|
while (*q == '/')
|
||||||
|
++q;
|
||||||
|
change = 1;
|
||||||
|
if (*q == '\0')
|
||||||
{
|
{
|
||||||
strcpy (path + i, path + i + 1);
|
*p = '\0';
|
||||||
i = (start < 0) ? 0 : start;
|
break;
|
||||||
changes = 1;
|
|
||||||
continue;
|
|
||||||
}
|
}
|
||||||
|
memmove (p, q, end - q);
|
||||||
|
end -= q - p;
|
||||||
|
goto again;
|
||||||
|
}
|
||||||
|
|
||||||
/* Handle `../' or trailing `..' by itself. */
|
/* Skip to the next path element. */
|
||||||
if (path[i + 1] == '.' &&
|
while (*p && *p != '/')
|
||||||
(path[i + 2] == '/' || !path[i + 2]))
|
++p;
|
||||||
{
|
if (*p == '\0')
|
||||||
while (--start > -1 && path[start] != '/');
|
|
||||||
strcpy (path + start + 1, path + i + 2 + (start == -1 && path[i + 2]));
|
|
||||||
i = (start < 0) ? 0 : start;
|
|
||||||
changes = 1;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
} /* path == '.' */
|
|
||||||
} /* while */
|
|
||||||
|
|
||||||
/* Addition: Remove all `./'-s and `../'-s preceding the string. */
|
|
||||||
i = 0;
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
if (path[i] == '.' && path[i + 1] == '/')
|
|
||||||
i += 2;
|
|
||||||
else if (path[i] == '.' && path[i + 1] == '.' && path[i + 2] == '/')
|
|
||||||
i += 3;
|
|
||||||
else
|
|
||||||
break;
|
break;
|
||||||
}
|
|
||||||
if (i)
|
/* Make sure P points to the beginning of the next path element,
|
||||||
{
|
which is location after the slash. */
|
||||||
strcpy (path, path + i - 0);
|
++p;
|
||||||
changes = 1;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
return changes;
|
return change;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Test cases:
|
|
||||||
ps("") -> ""
|
|
||||||
ps("/") -> "/"
|
|
||||||
ps(".") -> ""
|
|
||||||
ps("..") -> ""
|
|
||||||
ps("/.") -> "/"
|
|
||||||
ps("/..") -> "/"
|
|
||||||
ps("foo") -> "foo"
|
|
||||||
ps("foo/bar") -> "foo/bar"
|
|
||||||
ps("foo//bar") -> "foo/bar" (possibly a bug)
|
|
||||||
ps("foo/../bar") -> "bar"
|
|
||||||
ps("foo/bar/..") -> "foo/"
|
|
||||||
ps("foo/bar/../x") -> "foo/x"
|
|
||||||
ps("foo/bar/../x/") -> "foo/x/"
|
|
||||||
ps("foo/..") -> ""
|
|
||||||
ps("/foo/..") -> "/"
|
|
||||||
ps("a/b/../../c") -> "c"
|
|
||||||
ps("/a/b/../../c") -> "/c"
|
|
||||||
ps("./a/../b") -> "b"
|
|
||||||
ps("/./a/../b") -> "/b"
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* "Touch" FILE, i.e. make its atime and mtime equal to the time
|
/* "Touch" FILE, i.e. make its atime and mtime equal to the time
|
||||||
specified with TM. */
|
specified with TM. */
|
||||||
|
|
@ -1846,3 +1808,96 @@ debug_test_md5 (char *buf)
|
||||||
return res;
|
return res;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#if 0
|
||||||
|
/* Debugging and testing support for path_simplify. */
|
||||||
|
|
||||||
|
/* Debug: run path_simplify on PATH and return the result in a new
|
||||||
|
string. Useful for calling from the debugger. */
|
||||||
|
static char *
|
||||||
|
ps (char *path)
|
||||||
|
{
|
||||||
|
char *copy = xstrdup (path);
|
||||||
|
path_simplify (copy);
|
||||||
|
return copy;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
run_test (char *test, char *expected_result, int expected_change)
|
||||||
|
{
|
||||||
|
char *test_copy = xstrdup (test);
|
||||||
|
int modified = path_simplify (test_copy);
|
||||||
|
|
||||||
|
if (0 != strcmp (test_copy, expected_result))
|
||||||
|
{
|
||||||
|
printf ("Failed path_simplify(\"%s\"): expected \"%s\", got \"%s\".\n",
|
||||||
|
test, expected_result, test_copy);
|
||||||
|
}
|
||||||
|
if (modified != expected_change)
|
||||||
|
{
|
||||||
|
if (expected_change == 1)
|
||||||
|
printf ("Expected no modification with path_simplify(\"%s\").\n",
|
||||||
|
test);
|
||||||
|
else
|
||||||
|
printf ("Expected modification with path_simplify(\"%s\").\n",
|
||||||
|
test);
|
||||||
|
}
|
||||||
|
xfree (test_copy);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
test_path_simplify (void)
|
||||||
|
{
|
||||||
|
static struct {
|
||||||
|
char *test, *result;
|
||||||
|
int should_modify;
|
||||||
|
} tests[] = {
|
||||||
|
{ "", "", 0 },
|
||||||
|
{ ".", "", 1 },
|
||||||
|
{ "..", "", 1 },
|
||||||
|
{ "foo", "foo", 0 },
|
||||||
|
{ "foo/bar", "foo/bar", 0 },
|
||||||
|
{ "foo///bar", "foo/bar", 1 },
|
||||||
|
{ "foo/.", "foo/", 1 },
|
||||||
|
{ "foo/./", "foo/", 1 },
|
||||||
|
{ "foo./", "foo./", 0 },
|
||||||
|
{ "foo/../bar", "bar", 1 },
|
||||||
|
{ "foo/../bar/", "bar/", 1 },
|
||||||
|
{ "foo/bar/..", "foo/", 1 },
|
||||||
|
{ "foo/bar/../x", "foo/x", 1 },
|
||||||
|
{ "foo/bar/../x/", "foo/x/", 1 },
|
||||||
|
{ "foo/..", "", 1 },
|
||||||
|
{ "foo/../..", "", 1 },
|
||||||
|
{ "a/b/../../c", "c", 1 },
|
||||||
|
{ "./a/../b", "b", 1 }
|
||||||
|
};
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (i = 0; i < ARRAY_SIZE (tests); i++)
|
||||||
|
{
|
||||||
|
char *test = tests[i].test;
|
||||||
|
char *expected_result = tests[i].result;
|
||||||
|
int expected_change = tests[i].should_modify;
|
||||||
|
run_test (test, expected_result, expected_change);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Now run all the tests with a leading slash before the test case,
|
||||||
|
to prove that the slash is being preserved. */
|
||||||
|
for (i = 0; i < ARRAY_SIZE (tests); i++)
|
||||||
|
{
|
||||||
|
char *test, *expected_result;
|
||||||
|
int expected_change = tests[i].should_modify;
|
||||||
|
|
||||||
|
test = xmalloc (1 + strlen (tests[i].test) + 1);
|
||||||
|
sprintf (test, "/%s", tests[i].test);
|
||||||
|
|
||||||
|
expected_result = xmalloc (1 + strlen (tests[i].result) + 1);
|
||||||
|
sprintf (expected_result, "/%s", tests[i].result);
|
||||||
|
|
||||||
|
run_test (test, expected_result, expected_change);
|
||||||
|
|
||||||
|
xfree (test);
|
||||||
|
xfree (expected_result);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue