apply: do not get confused by symlinks in the middle
HPA noticed that git-rebase fails when changes involve symlinks
in the middle of the hierarchy. Consider:
* The tree state before the patch is applied has arch/x86_64/boot
as a symlink pointing at ../i386/boot/
* The patch tries to remove arch/x86_64/boot symlink, and
create bunch of files there: .gitignore, Makefile, etc.
git-apply tries to be careful while applying patches; it never
touches the working tree until it is convinced that the patch
would apply cleanly. One of the check it does is that when it
knows a path is going to be created by the patch, it runs
lstat() on the path to make sure it does not exist.
This leads to a false alarm. Because we do not touch the
working tree before all the check passes, when we try to make
sure that arch/x86_64/boot/.gitignore does not exist yet, we
haven't removed the arch/x86_64/boot symlink. The lstat() check
ends up seeing arch/i386/boot/.gitignore through the
yet-to-be-removed symlink, and says "Hey, you already have a
file there, but what you fed me is a patch to create a new
file. I am not going to clobber what you have in the working
tree."
We have similar checks to see a file we are going to modify does
exist and match the preimage of the diff, which is done by
directly opening and reading the file.
For a file we are going to delete, we make sure that it does
exist and matches what is going to be removed (a removal patch
records the full preimage, so we check what you have in your
working tree matches it in full -- otherwise we would risk
losing your local changes), which again is done by directly
opening and reading the file.
These checks need to be adjusted so that they are not fooled by
symlinks in the middle.
- To make sure something does not exist, first lstat(). If it
does not exist, it does not, so be happy. If it _does_, we
might be getting fooled by a symlink in the middle, so break
leading paths and see if there are symlinks involved. When
we are checking for a path a/b/c/d, if any of a, a/b, a/b/c
is a symlink, then a/b/c/d does _NOT_ exist, for the purpose
of our test.
This would fix this particular case you saw, and would not
add extra overhead in the usual case.
- To make sure something already exists, first lstat(). If it
does not exist, barf (up to this, we already do). Even if it
does seem to exist, we might be getting fooled by a symlink
in the middle, so make sure leading paths are not symlinks.
This would make the normal codepath much more expensive for
deep trees, which is a bit worrisome.
This patch implements the first side of the check "making sure
it does not exist". The latter "making sure it exists" check is
not done yet, so applying the patch in reverse would still
fail, but we have to start from somewhere.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-12 07:26:08 +02:00
|
|
|
#!/bin/sh
|
|
|
|
|
|
|
|
|
|
test_description='apply to deeper directory without getting fooled with symlink'
|
|
|
|
|
. ./test-lib.sh
|
|
|
|
|
|
2013-06-07 22:53:28 +02:00
|
|
|
test_expect_success setup '
|
apply: do not get confused by symlinks in the middle
HPA noticed that git-rebase fails when changes involve symlinks
in the middle of the hierarchy. Consider:
* The tree state before the patch is applied has arch/x86_64/boot
as a symlink pointing at ../i386/boot/
* The patch tries to remove arch/x86_64/boot symlink, and
create bunch of files there: .gitignore, Makefile, etc.
git-apply tries to be careful while applying patches; it never
touches the working tree until it is convinced that the patch
would apply cleanly. One of the check it does is that when it
knows a path is going to be created by the patch, it runs
lstat() on the path to make sure it does not exist.
This leads to a false alarm. Because we do not touch the
working tree before all the check passes, when we try to make
sure that arch/x86_64/boot/.gitignore does not exist yet, we
haven't removed the arch/x86_64/boot symlink. The lstat() check
ends up seeing arch/i386/boot/.gitignore through the
yet-to-be-removed symlink, and says "Hey, you already have a
file there, but what you fed me is a patch to create a new
file. I am not going to clobber what you have in the working
tree."
We have similar checks to see a file we are going to modify does
exist and match the preimage of the diff, which is done by
directly opening and reading the file.
For a file we are going to delete, we make sure that it does
exist and matches what is going to be removed (a removal patch
records the full preimage, so we check what you have in your
working tree matches it in full -- otherwise we would risk
losing your local changes), which again is done by directly
opening and reading the file.
These checks need to be adjusted so that they are not fooled by
symlinks in the middle.
- To make sure something does not exist, first lstat(). If it
does not exist, it does not, so be happy. If it _does_, we
might be getting fooled by a symlink in the middle, so break
leading paths and see if there are symlinks involved. When
we are checking for a path a/b/c/d, if any of a, a/b, a/b/c
is a symlink, then a/b/c/d does _NOT_ exist, for the purpose
of our test.
This would fix this particular case you saw, and would not
add extra overhead in the usual case.
- To make sure something already exists, first lstat(). If it
does not exist, barf (up to this, we already do). Even if it
does seem to exist, we might be getting fooled by a symlink
in the middle, so make sure leading paths are not symlinks.
This would make the normal codepath much more expensive for
deep trees, which is a bit worrisome.
This patch implements the first side of the check "making sure
it does not exist". The latter "making sure it exists" check is
not done yet, so applying the patch in reverse would still
fail, but we have to start from somewhere.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-12 07:26:08 +02:00
|
|
|
|
|
|
|
|
mkdir -p arch/i386/boot arch/x86_64 &&
|
2015-01-29 06:15:24 +01:00
|
|
|
test_write_lines 1 2 3 4 5 >arch/i386/boot/Makefile &&
|
2013-06-07 22:53:28 +02:00
|
|
|
test_ln_s_add ../i386/boot arch/x86_64/boot &&
|
apply: do not get confused by symlinks in the middle
HPA noticed that git-rebase fails when changes involve symlinks
in the middle of the hierarchy. Consider:
* The tree state before the patch is applied has arch/x86_64/boot
as a symlink pointing at ../i386/boot/
* The patch tries to remove arch/x86_64/boot symlink, and
create bunch of files there: .gitignore, Makefile, etc.
git-apply tries to be careful while applying patches; it never
touches the working tree until it is convinced that the patch
would apply cleanly. One of the check it does is that when it
knows a path is going to be created by the patch, it runs
lstat() on the path to make sure it does not exist.
This leads to a false alarm. Because we do not touch the
working tree before all the check passes, when we try to make
sure that arch/x86_64/boot/.gitignore does not exist yet, we
haven't removed the arch/x86_64/boot symlink. The lstat() check
ends up seeing arch/i386/boot/.gitignore through the
yet-to-be-removed symlink, and says "Hey, you already have a
file there, but what you fed me is a patch to create a new
file. I am not going to clobber what you have in the working
tree."
We have similar checks to see a file we are going to modify does
exist and match the preimage of the diff, which is done by
directly opening and reading the file.
For a file we are going to delete, we make sure that it does
exist and matches what is going to be removed (a removal patch
records the full preimage, so we check what you have in your
working tree matches it in full -- otherwise we would risk
losing your local changes), which again is done by directly
opening and reading the file.
These checks need to be adjusted so that they are not fooled by
symlinks in the middle.
- To make sure something does not exist, first lstat(). If it
does not exist, it does not, so be happy. If it _does_, we
might be getting fooled by a symlink in the middle, so break
leading paths and see if there are symlinks involved. When
we are checking for a path a/b/c/d, if any of a, a/b, a/b/c
is a symlink, then a/b/c/d does _NOT_ exist, for the purpose
of our test.
This would fix this particular case you saw, and would not
add extra overhead in the usual case.
- To make sure something already exists, first lstat(). If it
does not exist, barf (up to this, we already do). Even if it
does seem to exist, we might be getting fooled by a symlink
in the middle, so make sure leading paths are not symlinks.
This would make the normal codepath much more expensive for
deep trees, which is a bit worrisome.
This patch implements the first side of the check "making sure
it does not exist". The latter "making sure it exists" check is
not done yet, so applying the patch in reverse would still
fail, but we have to start from somewhere.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-12 07:26:08 +02:00
|
|
|
git add . &&
|
|
|
|
|
test_tick &&
|
|
|
|
|
git commit -m initial &&
|
|
|
|
|
git branch test &&
|
|
|
|
|
|
|
|
|
|
rm arch/x86_64/boot &&
|
|
|
|
|
mkdir arch/x86_64/boot &&
|
2015-01-29 06:15:24 +01:00
|
|
|
test_write_lines 2 3 4 5 6 >arch/x86_64/boot/Makefile &&
|
apply: do not get confused by symlinks in the middle
HPA noticed that git-rebase fails when changes involve symlinks
in the middle of the hierarchy. Consider:
* The tree state before the patch is applied has arch/x86_64/boot
as a symlink pointing at ../i386/boot/
* The patch tries to remove arch/x86_64/boot symlink, and
create bunch of files there: .gitignore, Makefile, etc.
git-apply tries to be careful while applying patches; it never
touches the working tree until it is convinced that the patch
would apply cleanly. One of the check it does is that when it
knows a path is going to be created by the patch, it runs
lstat() on the path to make sure it does not exist.
This leads to a false alarm. Because we do not touch the
working tree before all the check passes, when we try to make
sure that arch/x86_64/boot/.gitignore does not exist yet, we
haven't removed the arch/x86_64/boot symlink. The lstat() check
ends up seeing arch/i386/boot/.gitignore through the
yet-to-be-removed symlink, and says "Hey, you already have a
file there, but what you fed me is a patch to create a new
file. I am not going to clobber what you have in the working
tree."
We have similar checks to see a file we are going to modify does
exist and match the preimage of the diff, which is done by
directly opening and reading the file.
For a file we are going to delete, we make sure that it does
exist and matches what is going to be removed (a removal patch
records the full preimage, so we check what you have in your
working tree matches it in full -- otherwise we would risk
losing your local changes), which again is done by directly
opening and reading the file.
These checks need to be adjusted so that they are not fooled by
symlinks in the middle.
- To make sure something does not exist, first lstat(). If it
does not exist, it does not, so be happy. If it _does_, we
might be getting fooled by a symlink in the middle, so break
leading paths and see if there are symlinks involved. When
we are checking for a path a/b/c/d, if any of a, a/b, a/b/c
is a symlink, then a/b/c/d does _NOT_ exist, for the purpose
of our test.
This would fix this particular case you saw, and would not
add extra overhead in the usual case.
- To make sure something already exists, first lstat(). If it
does not exist, barf (up to this, we already do). Even if it
does seem to exist, we might be getting fooled by a symlink
in the middle, so make sure leading paths are not symlinks.
This would make the normal codepath much more expensive for
deep trees, which is a bit worrisome.
This patch implements the first side of the check "making sure
it does not exist". The latter "making sure it exists" check is
not done yet, so applying the patch in reverse would still
fail, but we have to start from somewhere.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-12 07:26:08 +02:00
|
|
|
git add . &&
|
|
|
|
|
test_tick &&
|
|
|
|
|
git commit -a -m second &&
|
|
|
|
|
|
|
|
|
|
git format-patch --binary -1 --stdout >test.patch
|
|
|
|
|
|
|
|
|
|
'
|
|
|
|
|
|
2013-06-07 22:53:28 +02:00
|
|
|
test_expect_success apply '
|
apply: do not get confused by symlinks in the middle
HPA noticed that git-rebase fails when changes involve symlinks
in the middle of the hierarchy. Consider:
* The tree state before the patch is applied has arch/x86_64/boot
as a symlink pointing at ../i386/boot/
* The patch tries to remove arch/x86_64/boot symlink, and
create bunch of files there: .gitignore, Makefile, etc.
git-apply tries to be careful while applying patches; it never
touches the working tree until it is convinced that the patch
would apply cleanly. One of the check it does is that when it
knows a path is going to be created by the patch, it runs
lstat() on the path to make sure it does not exist.
This leads to a false alarm. Because we do not touch the
working tree before all the check passes, when we try to make
sure that arch/x86_64/boot/.gitignore does not exist yet, we
haven't removed the arch/x86_64/boot symlink. The lstat() check
ends up seeing arch/i386/boot/.gitignore through the
yet-to-be-removed symlink, and says "Hey, you already have a
file there, but what you fed me is a patch to create a new
file. I am not going to clobber what you have in the working
tree."
We have similar checks to see a file we are going to modify does
exist and match the preimage of the diff, which is done by
directly opening and reading the file.
For a file we are going to delete, we make sure that it does
exist and matches what is going to be removed (a removal patch
records the full preimage, so we check what you have in your
working tree matches it in full -- otherwise we would risk
losing your local changes), which again is done by directly
opening and reading the file.
These checks need to be adjusted so that they are not fooled by
symlinks in the middle.
- To make sure something does not exist, first lstat(). If it
does not exist, it does not, so be happy. If it _does_, we
might be getting fooled by a symlink in the middle, so break
leading paths and see if there are symlinks involved. When
we are checking for a path a/b/c/d, if any of a, a/b, a/b/c
is a symlink, then a/b/c/d does _NOT_ exist, for the purpose
of our test.
This would fix this particular case you saw, and would not
add extra overhead in the usual case.
- To make sure something already exists, first lstat(). If it
does not exist, barf (up to this, we already do). Even if it
does seem to exist, we might be getting fooled by a symlink
in the middle, so make sure leading paths are not symlinks.
This would make the normal codepath much more expensive for
deep trees, which is a bit worrisome.
This patch implements the first side of the check "making sure
it does not exist". The latter "making sure it exists" check is
not done yet, so applying the patch in reverse would still
fail, but we have to start from somewhere.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-12 07:26:08 +02:00
|
|
|
|
|
|
|
|
git checkout test &&
|
|
|
|
|
git diff --exit-code test &&
|
|
|
|
|
git diff --exit-code --cached test &&
|
|
|
|
|
git apply --index test.patch
|
|
|
|
|
|
|
|
|
|
'
|
|
|
|
|
|
2013-06-07 22:53:28 +02:00
|
|
|
test_expect_success 'check result' '
|
apply: do not get confused by symlinks in the middle
HPA noticed that git-rebase fails when changes involve symlinks
in the middle of the hierarchy. Consider:
* The tree state before the patch is applied has arch/x86_64/boot
as a symlink pointing at ../i386/boot/
* The patch tries to remove arch/x86_64/boot symlink, and
create bunch of files there: .gitignore, Makefile, etc.
git-apply tries to be careful while applying patches; it never
touches the working tree until it is convinced that the patch
would apply cleanly. One of the check it does is that when it
knows a path is going to be created by the patch, it runs
lstat() on the path to make sure it does not exist.
This leads to a false alarm. Because we do not touch the
working tree before all the check passes, when we try to make
sure that arch/x86_64/boot/.gitignore does not exist yet, we
haven't removed the arch/x86_64/boot symlink. The lstat() check
ends up seeing arch/i386/boot/.gitignore through the
yet-to-be-removed symlink, and says "Hey, you already have a
file there, but what you fed me is a patch to create a new
file. I am not going to clobber what you have in the working
tree."
We have similar checks to see a file we are going to modify does
exist and match the preimage of the diff, which is done by
directly opening and reading the file.
For a file we are going to delete, we make sure that it does
exist and matches what is going to be removed (a removal patch
records the full preimage, so we check what you have in your
working tree matches it in full -- otherwise we would risk
losing your local changes), which again is done by directly
opening and reading the file.
These checks need to be adjusted so that they are not fooled by
symlinks in the middle.
- To make sure something does not exist, first lstat(). If it
does not exist, it does not, so be happy. If it _does_, we
might be getting fooled by a symlink in the middle, so break
leading paths and see if there are symlinks involved. When
we are checking for a path a/b/c/d, if any of a, a/b, a/b/c
is a symlink, then a/b/c/d does _NOT_ exist, for the purpose
of our test.
This would fix this particular case you saw, and would not
add extra overhead in the usual case.
- To make sure something already exists, first lstat(). If it
does not exist, barf (up to this, we already do). Even if it
does seem to exist, we might be getting fooled by a symlink
in the middle, so make sure leading paths are not symlinks.
This would make the normal codepath much more expensive for
deep trees, which is a bit worrisome.
This patch implements the first side of the check "making sure
it does not exist". The latter "making sure it exists" check is
not done yet, so applying the patch in reverse would still
fail, but we have to start from somewhere.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-12 07:26:08 +02:00
|
|
|
|
|
|
|
|
git diff --exit-code master &&
|
|
|
|
|
git diff --exit-code --cached master &&
|
|
|
|
|
test_tick &&
|
|
|
|
|
git commit -m replay &&
|
|
|
|
|
T1=$(git rev-parse "master^{tree}") &&
|
|
|
|
|
T2=$(git rev-parse "HEAD^{tree}") &&
|
|
|
|
|
test "z$T1" = "z$T2"
|
|
|
|
|
|
|
|
|
|
'
|
|
|
|
|
|
2015-01-31 00:34:13 +01:00
|
|
|
test_expect_success SYMLINKS 'do not read from beyond symbolic link' '
|
|
|
|
|
git reset --hard &&
|
|
|
|
|
mkdir -p arch/x86_64/dir &&
|
|
|
|
|
>arch/x86_64/dir/file &&
|
|
|
|
|
git add arch/x86_64/dir/file &&
|
|
|
|
|
echo line >arch/x86_64/dir/file &&
|
|
|
|
|
git diff >patch &&
|
|
|
|
|
git reset --hard &&
|
|
|
|
|
|
|
|
|
|
mkdir arch/i386/dir &&
|
|
|
|
|
>arch/i386/dir/file &&
|
|
|
|
|
ln -s ../i386/dir arch/x86_64/dir &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git apply patch &&
|
|
|
|
|
test_must_fail git apply --cached patch &&
|
|
|
|
|
test_must_fail git apply --index patch
|
|
|
|
|
|
|
|
|
|
'
|
|
|
|
|
|
apply: do not touch a file beyond a symbolic link
Because Git tracks symbolic links as symbolic links, a path that
has a symbolic link in its leading part (e.g. path/to/dir/file,
where path/to/dir is a symbolic link to somewhere else, be it
inside or outside the working tree) can never appear in a patch
that validly applies, unless the same patch first removes the
symbolic link to allow a directory to be created there.
Detect and reject such a patch.
Things to note:
- Unfortunately, we cannot reuse the has_symlink_leading_path()
from dir.c, as that is only about the working tree, but "git
apply" can be told to apply the patch only to the index or to
both the index and to the working tree.
- We cannot directly use has_symlink_leading_path() even when we
are applying only to the working tree, as an early patch of a
valid input may remove a symbolic link path/to/dir and then a
later patch of the input may create a path path/to/dir/file, but
"git apply" first checks the input without touching either the
index or the working tree. The leading symbolic link check must
be done on the interim result we compute in-core (i.e. after the
first patch, there is no path/to/dir symbolic link and it is
perfectly valid to create path/to/dir/file).
Similarly, when an input creates a symbolic link path/to/dir and
then creates a file path/to/dir/file, we need to flag it as an
error without actually creating path/to/dir symbolic link in the
filesystem.
Instead, for any patch in the input that leaves a path (i.e. a non
deletion) in the result, we check all leading paths against the
resulting tree that the patch would create by inspecting all the
patches in the input and then the target of patch application
(either the index or the working tree).
This way, we catch a mischief or a mistake to add a symbolic link
path/to/dir and a file path/to/dir/file at the same time, while
allowing a valid patch that removes a symbolic link path/to/dir and
then adds a file path/to/dir/file.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-01-29 21:41:22 +01:00
|
|
|
test_expect_success SYMLINKS 'do not follow symbolic link (setup)' '
|
|
|
|
|
|
|
|
|
|
rm -rf arch/i386/dir arch/x86_64/dir &&
|
|
|
|
|
git reset --hard &&
|
|
|
|
|
ln -s ../i386/dir arch/x86_64/dir &&
|
|
|
|
|
git add arch/x86_64/dir &&
|
|
|
|
|
git diff HEAD >add_symlink.patch &&
|
|
|
|
|
git reset --hard &&
|
|
|
|
|
|
|
|
|
|
mkdir arch/x86_64/dir &&
|
|
|
|
|
>arch/x86_64/dir/file &&
|
|
|
|
|
git add arch/x86_64/dir/file &&
|
|
|
|
|
git diff HEAD >add_file.patch &&
|
|
|
|
|
git diff -R HEAD >del_file.patch &&
|
|
|
|
|
git reset --hard &&
|
|
|
|
|
rm -fr arch/x86_64/dir &&
|
|
|
|
|
|
|
|
|
|
cat add_symlink.patch add_file.patch >patch &&
|
|
|
|
|
cat add_symlink.patch del_file.patch >tricky_del &&
|
|
|
|
|
|
|
|
|
|
mkdir arch/i386/dir
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success SYMLINKS 'do not follow symbolic link (same input)' '
|
|
|
|
|
|
|
|
|
|
# same input creates a confusing symbolic link
|
|
|
|
|
test_must_fail git apply patch 2>error-wt &&
|
|
|
|
|
test_i18ngrep "beyond a symbolic link" error-wt &&
|
|
|
|
|
test_path_is_missing arch/x86_64/dir &&
|
|
|
|
|
test_path_is_missing arch/i386/dir/file &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git apply --index patch 2>error-ix &&
|
|
|
|
|
test_i18ngrep "beyond a symbolic link" error-ix &&
|
|
|
|
|
test_path_is_missing arch/x86_64/dir &&
|
|
|
|
|
test_path_is_missing arch/i386/dir/file &&
|
|
|
|
|
test_must_fail git ls-files --error-unmatch arch/x86_64/dir &&
|
|
|
|
|
test_must_fail git ls-files --error-unmatch arch/i386/dir &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git apply --cached patch 2>error-ct &&
|
|
|
|
|
test_i18ngrep "beyond a symbolic link" error-ct &&
|
|
|
|
|
test_must_fail git ls-files --error-unmatch arch/x86_64/dir &&
|
|
|
|
|
test_must_fail git ls-files --error-unmatch arch/i386/dir &&
|
|
|
|
|
|
|
|
|
|
>arch/i386/dir/file &&
|
|
|
|
|
git add arch/i386/dir/file &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git apply tricky_del &&
|
|
|
|
|
test_path_is_file arch/i386/dir/file &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git apply --index tricky_del &&
|
|
|
|
|
test_path_is_file arch/i386/dir/file &&
|
|
|
|
|
test_must_fail git ls-files --error-unmatch arch/x86_64/dir &&
|
|
|
|
|
git ls-files --error-unmatch arch/i386/dir &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git apply --cached tricky_del &&
|
|
|
|
|
test_must_fail git ls-files --error-unmatch arch/x86_64/dir &&
|
|
|
|
|
git ls-files --error-unmatch arch/i386/dir
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success SYMLINKS 'do not follow symbolic link (existing)' '
|
|
|
|
|
|
|
|
|
|
# existing symbolic link
|
|
|
|
|
git reset --hard &&
|
|
|
|
|
ln -s ../i386/dir arch/x86_64/dir &&
|
|
|
|
|
git add arch/x86_64/dir &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git apply add_file.patch 2>error-wt-add &&
|
|
|
|
|
test_i18ngrep "beyond a symbolic link" error-wt-add &&
|
|
|
|
|
test_path_is_missing arch/i386/dir/file &&
|
|
|
|
|
|
|
|
|
|
mkdir arch/i386/dir &&
|
|
|
|
|
>arch/i386/dir/file &&
|
|
|
|
|
test_must_fail git apply del_file.patch 2>error-wt-del &&
|
|
|
|
|
test_i18ngrep "beyond a symbolic link" error-wt-del &&
|
|
|
|
|
test_path_is_file arch/i386/dir/file &&
|
|
|
|
|
rm arch/i386/dir/file &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git apply --index add_file.patch 2>error-ix-add &&
|
|
|
|
|
test_i18ngrep "beyond a symbolic link" error-ix-add &&
|
|
|
|
|
test_path_is_missing arch/i386/dir/file &&
|
|
|
|
|
test_must_fail git ls-files --error-unmatch arch/i386/dir &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git apply --cached add_file.patch 2>error-ct-file &&
|
|
|
|
|
test_i18ngrep "beyond a symbolic link" error-ct-file &&
|
|
|
|
|
test_must_fail git ls-files --error-unmatch arch/i386/dir
|
|
|
|
|
'
|
|
|
|
|
|
apply: do not get confused by symlinks in the middle
HPA noticed that git-rebase fails when changes involve symlinks
in the middle of the hierarchy. Consider:
* The tree state before the patch is applied has arch/x86_64/boot
as a symlink pointing at ../i386/boot/
* The patch tries to remove arch/x86_64/boot symlink, and
create bunch of files there: .gitignore, Makefile, etc.
git-apply tries to be careful while applying patches; it never
touches the working tree until it is convinced that the patch
would apply cleanly. One of the check it does is that when it
knows a path is going to be created by the patch, it runs
lstat() on the path to make sure it does not exist.
This leads to a false alarm. Because we do not touch the
working tree before all the check passes, when we try to make
sure that arch/x86_64/boot/.gitignore does not exist yet, we
haven't removed the arch/x86_64/boot symlink. The lstat() check
ends up seeing arch/i386/boot/.gitignore through the
yet-to-be-removed symlink, and says "Hey, you already have a
file there, but what you fed me is a patch to create a new
file. I am not going to clobber what you have in the working
tree."
We have similar checks to see a file we are going to modify does
exist and match the preimage of the diff, which is done by
directly opening and reading the file.
For a file we are going to delete, we make sure that it does
exist and matches what is going to be removed (a removal patch
records the full preimage, so we check what you have in your
working tree matches it in full -- otherwise we would risk
losing your local changes), which again is done by directly
opening and reading the file.
These checks need to be adjusted so that they are not fooled by
symlinks in the middle.
- To make sure something does not exist, first lstat(). If it
does not exist, it does not, so be happy. If it _does_, we
might be getting fooled by a symlink in the middle, so break
leading paths and see if there are symlinks involved. When
we are checking for a path a/b/c/d, if any of a, a/b, a/b/c
is a symlink, then a/b/c/d does _NOT_ exist, for the purpose
of our test.
This would fix this particular case you saw, and would not
add extra overhead in the usual case.
- To make sure something already exists, first lstat(). If it
does not exist, barf (up to this, we already do). Even if it
does seem to exist, we might be getting fooled by a symlink
in the middle, so make sure leading paths are not symlinks.
This would make the normal codepath much more expensive for
deep trees, which is a bit worrisome.
This patch implements the first side of the check "making sure
it does not exist". The latter "making sure it exists" check is
not done yet, so applying the patch in reverse would still
fail, but we have to start from somewhere.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-12 07:26:08 +02:00
|
|
|
test_done
|