# [PATCH v5 2/3] connect: tighten check for unexpected early hang up 5 messages from 2016-09-09 to 2016-09-09. Participants: Jonathan Tan, Jonathan Nieder. Thread: https://gitlist.dev/t/44050 ## Jonathan Tan, 2016-09-09 20:17 Subject: [PATCH v5 2/3] connect: tighten check for unexpected early hang up Message-ID: <691658f3d805e3d8515e7b05f7f46d969b9bb301.1473452153.git.jonathantanmy@google.com> URL: https://gitlist.dev/e/691658f3d805e3d8515e7b05f7f46d969b9bb301.1473452153.git.jonathantanmy%40google.com In-Reply-To: ``` From: Jonathan Nieder A server hanging up immediately to mark access being denied does not send any .have refs, shallow lines, or anything else before hanging up. If the server has sent anything, then the hangup is unexpected. That is, if the server hangs up after a shallow line but before sending any refs, then git should tell me so: fatal: The remote end hung up upon initial contact instead of suggesting an access control problem: fatal: Could not read from remote repository. Please make sure you have the correct access rights and the repository exists. Noticed while examining this code. This case isn't likely to come up in practice but tightening the check makes the code easier to read and manipulate. Signed-off-by: Jonathan Nieder Signed-off-by: Junio C Hamano --- connect.c | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/connect.c b/connect.c index 722dc3f..0c01a49 100644 --- a/connect.c +++ b/connect.c @@ -43,9 +43,9 @@ int check_ref_type(const struct ref *ref, int flags) return check_ref(ref->name, flags); } -static void die_initial_contact(int got_at_least_one_head) +static void die_initial_contact(int unexpected) { - if (got_at_least_one_head) + if (unexpected) die("The remote end hung up upon initial contact"); else die("Could not read from remote repository.\n\n" @@ -115,10 +115,17 @@ struct ref **get_remote_heads(int in, char *src_buf, size_t src_len, struct sha1_array *shallow_points) { struct ref **orig_list = list; - int got_at_least_one_head = 0; + + /* + * A hang-up after seeing some response from the other end + * means that it is unexpected, as we know the other end is + * willing to talk to us. A hang-up before seeing any + * response does not necessarily mean an ACL problem, though. + */ + int saw_response; *list = NULL; - for (;;) { + for (saw_response = 0; ; saw_response = 1) { struct ref *ref; struct object_id old_oid; char *name; @@ -131,7 +138,7 @@ struct ref **get_remote_heads(int in, char *src_buf, size_t src_len, PACKET_READ_GENTLE_ON_EOF | PACKET_READ_CHOMP_NEWLINE); if (len < 0) - die_initial_contact(got_at_least_one_head); + die_initial_contact(saw_response); if (!len) break; @@ -171,7 +178,6 @@ struct ref **get_remote_heads(int in, char *src_buf, size_t src_len, oidcpy(&ref->old_oid, &old_oid); *list = ref; list = &ref->next; - got_at_least_one_head = 1; } annotate_refs_with_symref_info(*orig_list); -- 2.8.0.rc3.226.g39d4020 ``` ## Jonathan Tan, 2016-09-09 20:17 Subject: [PATCH v5 0/3] handle empty spec-compliant remote repos correctly Message-ID: URL: https://gitlist.dev/e/cover.1473452153.git.jonathantanmy%40google.com In-Reply-To: ``` Updates from PATCH v4: o use fatal errors ("die") instead of warnings for protocol errors o reworded commit message - removed last sentence and wrote "(following the specification in pack-protocol.txt)" in one of the earlier paragraphs Jonathan Nieder (1): connect: tighten check for unexpected early hang up Jonathan Tan (2): tests: move test_lazy_prereq JGIT to test-lib.sh connect: advertized capability is not a ref connect.c | 32 ++++++++++++++++++++++++++------ t/t5310-pack-bitmaps.sh | 4 ---- t/t5512-ls-remote.sh | 40 ++++++++++++++++++++++++++++++++++++++++ t/test-lib.sh | 4 ++++ 4 files changed, 70 insertions(+), 10 deletions(-) -- 2.8.0.rc3.226.g39d4020 ``` ## Jonathan Tan, 2016-09-09 20:17 Subject: [PATCH v5 1/3] tests: move test_lazy_prereq JGIT to test-lib.sh Message-ID: <37c4e775948b88b2d5af1caee3a70e36f00bc88a.1473452153.git.jonathantanmy@google.com> URL: https://gitlist.dev/e/37c4e775948b88b2d5af1caee3a70e36f00bc88a.1473452153.git.jonathantanmy%40google.com In-Reply-To: ``` This enables JGIT to be used as a prereq in invocations of test_expect_success (and other functions) in other test scripts. Signed-off-by: Jonathan Tan --- t/t5310-pack-bitmaps.sh | 4 ---- t/test-lib.sh | 4 ++++ 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/t/t5310-pack-bitmaps.sh b/t/t5310-pack-bitmaps.sh index 3893afd..1e376ea 100755 --- a/t/t5310-pack-bitmaps.sh +++ b/t/t5310-pack-bitmaps.sh @@ -158,10 +158,6 @@ test_expect_success 'pack with missing parent' ' git pack-objects --stdout --revs /dev/null ' -test_lazy_prereq JGIT ' - type jgit -' - test_expect_success JGIT 'we can read jgit bitmaps' ' git clone . compat-jgit && ( diff --git a/t/test-lib.sh b/t/test-lib.sh index d731d66..c9c1037 100644 --- a/t/test-lib.sh +++ b/t/test-lib.sh @@ -1072,6 +1072,10 @@ test_lazy_prereq NOT_ROOT ' test "$uid" != 0 ' +test_lazy_prereq JGIT ' + type jgit +' + # SANITY is about "can you correctly predict what the filesystem would # do by only looking at the permission bits of the files and # directories?" A typical example of !SANITY is running the test -- 2.8.0.rc3.226.g39d4020 ``` ## Jonathan Tan, 2016-09-09 20:17 Subject: [PATCH v5 3/3] connect: advertized capability is not a ref Message-ID: URL: https://gitlist.dev/e/f2ccb239ba1f85b434c3dfa60e86b89c414dfffa.1473452153.git.jonathantanmy%40google.com In-Reply-To: ``` When cloning an empty repository served by standard git, "git clone" produces the following reassuring message: $ git clone git://localhost/tmp/empty Cloning into 'empty'... warning: You appear to have cloned an empty repository. Checking connectivity... done. Meanwhile when cloning an empty repository served by JGit, the output is more haphazard: $ git clone git://localhost/tmp/empty Cloning into 'empty'... Checking connectivity... done. warning: remote HEAD refers to nonexistent ref, unable to checkout. This is a common command to run immediately after creating a remote repository as preparation for adding content to populate it and pushing. The warning is confusing and needlessly worrying. The cause is that, since v3.1.0.201309270735-rc1~22 (Advertise capabilities with no refs in upload service., 2013-08-08), JGit's ref advertisement includes a ref named capabilities^{} to advertise its capabilities on (following the specification in pack-protocol.txt), while git's ref advertisement is empty in this case. This allows the client to learn about the server's capabilities and is needed, for example, for fetch-by-sha1 to work when no refs are advertised. This also affects "ls-remote". For example, against an empty repository served by JGit: $ git ls-remote git://localhost/tmp/empty 0000000000000000000000000000000000000000 capabilities^{} Git advertises the same capabilities^{} ref in its ref advertisement for push but since it never did so for fetch, the client didn't need to handle this case. Handle it. Signed-off-by: Jonathan Tan --- connect.c | 14 ++++++++++++++ t/t5512-ls-remote.sh | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+) diff --git a/connect.c b/connect.c index 0c01a49..7224b5e 100644 --- a/connect.c +++ b/connect.c @@ -123,6 +123,7 @@ struct ref **get_remote_heads(int in, char *src_buf, size_t src_len, * response does not necessarily mean an ACL problem, though. */ int saw_response; + int got_dummy_ref_with_capabilities_declaration = 0; *list = NULL; for (saw_response = 0; ; saw_response = 1) { @@ -172,8 +173,21 @@ struct ref **get_remote_heads(int in, char *src_buf, size_t src_len, continue; } + if (!strcmp(name, "capabilities^{}")) { + if (saw_response) + die("protocol error: unexpected capabilities^{}"); + if (got_dummy_ref_with_capabilities_declaration) + die("protocol error: multiple capabilities^{}"); + got_dummy_ref_with_capabilities_declaration = 1; + continue; + } + if (!check_ref(name, flags)) continue; + + if (got_dummy_ref_with_capabilities_declaration) + die("protocol error: unexpected ref after capabilities^{}"); + ref = alloc_ref(buffer + GIT_SHA1_HEXSZ + 1); oidcpy(&ref->old_oid, &old_oid); *list = ref; diff --git a/t/t5512-ls-remote.sh b/t/t5512-ls-remote.sh index 819b9dd..befdfee 100755 --- a/t/t5512-ls-remote.sh +++ b/t/t5512-ls-remote.sh @@ -207,5 +207,45 @@ test_expect_success 'ls-remote --symref omits filtered-out matches' ' test_cmp expect actual ' +test_lazy_prereq GIT_DAEMON ' + test_tristate GIT_TEST_GIT_DAEMON && + test "$GIT_TEST_GIT_DAEMON" != false +' + +# This test spawns a daemon, so run it only if the user would be OK with +# testing with git-daemon. +test_expect_success PIPE,JGIT,GIT_DAEMON 'indicate no refs in standards-compliant empty remote' ' + JGIT_DAEMON_PORT=${JGIT_DAEMON_PORT-${this_test#t}} && + JGIT_DAEMON_PID= && + git init --bare empty.git && + >empty.git/git-daemon-export-ok && + mkfifo jgit_daemon_output && + { + jgit daemon --port="$JGIT_DAEMON_PORT" . >jgit_daemon_output & + JGIT_DAEMON_PID=$! + } && + test_when_finished kill "$JGIT_DAEMON_PID" && + { + read line && + case $line in + Exporting*) + ;; + *) + echo "Expected: Exporting" && + false;; + esac && + read line && + case $line in + "Listening on"*) + ;; + *) + echo "Expected: Listening on" && + false;; + esac + } URL: https://gitlist.dev/e/20160909210757.GH25016%40google.com In-Reply-To: ``` Jonathan Tan wrote: > connect.c | 32 ++++++++++++++++++++++++++------ > t/t5310-pack-bitmaps.sh | 4 ---- > t/t5512-ls-remote.sh | 40 ++++++++++++++++++++++++++++++++++++++++ > t/test-lib.sh | 4 ++++ > 4 files changed, 70 insertions(+), 10 deletions(-) Reviewed-by: Jonathan Nieder Thank you, Jonathan ```