remove the impression of unexpectedness when access is denied

If a server accessed through ssh is denying access git will currently
issue the message

"fatal: The remote end hung up unexpectedly"

as the last line. This sounds as if something really ugly just happened.
Since this is a quite typical situation in which users regularly get
we do not say that if it happens at the beginning when reading the
remote heads.

If its in the very first beginning of reading the remote heads it is
very likely an authentication error or a missing repository.

If it happens later during reading the remote heads we still indicate
that it happened during this initial contact phase.

Signed-off-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/connect.c b/connect.c
index d2ce57f850fa6d0a6de04f6f714dec487ff9f1ed..fe6e9214b29cc0d53accabcd3d88be53ed0b0129 100644 (file)
--- a/connect.c
+++ b/connect.c
@@ -49,6 +49,16 @@ static void add_extra_have(struct extra_have_objects *extra, unsigned char *sha1
        extra->nr++;
 }
 
        extra->nr++;
 }
 

+static void die_initial_contact(int got_at_least_one_head)
+{
+       if (got_at_least_one_head)
+               die("The remote end hung up upon initial contact");
+       else
+               die("Could not read from remote repository.\n\n"
+                   "Please make sure you have the correct access rights\n"
+                   "and the repository exists.");
+}
+

 /*
  * Read all the refs from the other end
  */
 /*
  * Read all the refs from the other end
  */


@@ -57,6 +67,8 @@ struct ref **get_remote_heads(int in, struct ref **list,
                              unsigned int flags,
                              struct extra_have_objects *extra_have)
 {
                              unsigned int flags,
                              struct extra_have_objects *extra_have)
 {

+       int got_at_least_one_head = 0;
+

        *list = NULL;
        for (;;) {
                struct ref *ref;
        *list = NULL;
        for (;;) {
                struct ref *ref;


@@ -65,7 +77,10 @@ struct ref **get_remote_heads(int in, struct ref **list,
                char *name;
                int len, name_len;
 
                char *name;
                int len, name_len;
 

-               len = packet_read_line(in, buffer, sizeof(buffer));
+               len = packet_read(in, buffer, sizeof(buffer));
+               if (len < 0)
+                       die_initial_contact(got_at_least_one_head);
+

                if (!len)
                        break;
                if (buffer[len-1] == '\n')
                if (!len)
                        break;
                if (buffer[len-1] == '\n')


@@ -98,6 +113,7 @@ struct ref **get_remote_heads(int in, struct ref **list,
                hashcpy(ref->old_sha1, old_sha1);
                *list = ref;
                list = &ref->next;
                hashcpy(ref->old_sha1, old_sha1);
                *list = ref;
                list = &ref->next;

+               got_at_least_one_head = 1;

        }
        return list;
 }
        }
        return list;
 }

diff --git a/pkt-line.c b/pkt-line.c
index 5a04984ea31744528de30269add2754ed2dcd105..eaba15f124b5d8247d39bd0844967cb5a9101ba8 100644 (file)
--- a/pkt-line.c
+++ b/pkt-line.c
@@ -135,13 +135,19 @@ void packet_buf_write(struct strbuf *buf, const char *fmt, ...)
        strbuf_add(buf, buffer, n);
 }
 
        strbuf_add(buf, buffer, n);
 }
 

-static void safe_read(int fd, void *buffer, unsigned size)
+static int safe_read(int fd, void *buffer, unsigned size, int return_line_fail)

 {
        ssize_t ret = read_in_full(fd, buffer, size);
        if (ret < 0)
                die_errno("read error");
 {
        ssize_t ret = read_in_full(fd, buffer, size);
        if (ret < 0)
                die_errno("read error");

-       else if (ret < size)
+       else if (ret < size) {
+               if (return_line_fail)
+                       return -1;
+

                die("The remote end hung up unexpectedly");
                die("The remote end hung up unexpectedly");

+       }
+
+       return ret;

 }
 
 static int packet_length(const char *linelen)
 }
 
 static int packet_length(const char *linelen)


@@ -169,12 +175,14 @@ static int packet_length(const char *linelen)
        return len;
 }
 
        return len;
 }
 

-int packet_read_line(int fd, char *buffer, unsigned size)
+static int packet_read_internal(int fd, char *buffer, unsigned size, int return_line_fail)

 {
 {

-       int len;
+       int len, ret;

        char linelen[4];
 
        char linelen[4];
 

-       safe_read(fd, linelen, 4);
+       ret = safe_read(fd, linelen, 4, return_line_fail);
+       if (return_line_fail && ret < 0)
+               return ret;

        len = packet_length(linelen);
        if (len < 0)
                die("protocol error: bad line length character: %.4s", linelen);
        len = packet_length(linelen);
        if (len < 0)
                die("protocol error: bad line length character: %.4s", linelen);


@@ -185,12 +193,24 @@ int packet_read_line(int fd, char *buffer, unsigned size)
        len -= 4;
        if (len >= size)
                die("protocol error: bad line length %d", len);
        len -= 4;
        if (len >= size)
                die("protocol error: bad line length %d", len);

-       safe_read(fd, buffer, len);
+       ret = safe_read(fd, buffer, len, return_line_fail);
+       if (return_line_fail && ret < 0)
+               return ret;

        buffer[len] = 0;
        packet_trace(buffer, len, 0);
        return len;
 }
 
        buffer[len] = 0;
        packet_trace(buffer, len, 0);
        return len;
 }
 

+int packet_read(int fd, char *buffer, unsigned size)
+{
+       return packet_read_internal(fd, buffer, size, 1);
+}
+
+int packet_read_line(int fd, char *buffer, unsigned size)
+{
+       return packet_read_internal(fd, buffer, size, 0);
+}
+

 int packet_get_line(struct strbuf *out,
        char **src_buf, size_t *src_len)
 {
 int packet_get_line(struct strbuf *out,
        char **src_buf, size_t *src_len)
 {

diff --git a/pkt-line.h b/pkt-line.h
index 1e5dcfe87c568eaa7746091b1eb059834f4913bb..8cfeb0c31c8661bf11ce78d3679a21cd030ffb75 100644 (file)
--- a/pkt-line.h
+++ b/pkt-line.h
@@ -13,6 +13,7 @@ void packet_buf_flush(struct strbuf *buf);
 void packet_buf_write(struct strbuf *buf, const char *fmt, ...) __attribute__((format (printf, 2, 3)));
 
 int packet_read_line(int fd, char *buffer, unsigned size);
 void packet_buf_write(struct strbuf *buf, const char *fmt, ...) __attribute__((format (printf, 2, 3)));
 
 int packet_read_line(int fd, char *buffer, unsigned size);

+int packet_read(int fd, char *buffer, unsigned size);

 int packet_get_line(struct strbuf *out, char **src_buf, size_t *src_len);
 ssize_t safe_write(int, const void *, ssize_t);
 
 int packet_get_line(struct strbuf *out, char **src_buf, size_t *src_len);
 ssize_t safe_write(int, const void *, ssize_t);
 

diff --git a/t/t5512-ls-remote.sh b/t/t5512-ls-remote.sh
index 5c546c99a58854ae0f430e469dad525af52e9292..2ab66d6e3383097079406d1aeab91737567d2875 100755 (executable)
--- a/t/t5512-ls-remote.sh
+++ b/t/t5512-ls-remote.sh
@@ -104,18 +104,16 @@ test_expect_success 'use branch.<name>.remote if possible' '
 
 cat >exp <<EOF
 fatal: 'refs*master' does not appear to be a git repository
 
 cat >exp <<EOF
 fatal: 'refs*master' does not appear to be a git repository

-fatal: The remote end hung up unexpectedly
+fatal: Could not read from remote repository.
+
+Please make sure you have the correct access rights
+and the repository exists.

 EOF
 test_expect_success 'confuses pattern as remote when no remote specified' '
        #
 EOF
 test_expect_success 'confuses pattern as remote when no remote specified' '
        #

-       # Do not expect "git ls-remote <pattern>" to work; ls-remote, correctly,
-       # confuses <pattern> for <remote>. Although ugly, this behaviour is akin
-       # to the confusion of refspecs for remotes by git-fetch and git-push,
-       # eg:
-       #
-       #   $ git fetch branch
-       #
-
+       # Do not expect "git ls-remote <pattern>" to work; ls-remote needs
+       # <remote> if you want to feed <pattern>, just like you cannot say
+       # fetch <branch>.

        # We could just as easily have used "master"; the "*" emphasizes its
        # role as a pattern.
        test_must_fail git ls-remote refs*master >actual 2>&1 &&
        # We could just as easily have used "master"; the "*" emphasizes its
        # role as a pattern.
        test_must_fail git ls-remote refs*master >actual 2>&1 &&