Merge branch 'jt/clone-unborn-head'

"git clone" tries to locally check out the branch pointed at by
HEAD of the remote repository after it is done, but the protocol
did not convey the information necessary to do so when copying an
empty repository.  The protocol v2 learned how to do so.

* jt/clone-unborn-head:
  clone: respect remote unborn HEAD
  connect, transport: encapsulate arg in struct
  ls-refs: report unborn targets of symrefs

diff --git a/Documentation/config.txt b/Documentation/config.txt
index 6ba50b1104aa798cc80c92a521da39a026d82955..d08e83a1482ed4174d9003fba302b4dca5e7b9ed 100644 (file)
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -398,6 +398,8 @@ include::config/interactive.txt[]
 
 include::config/log.txt[]
 
+include::config/lsrefs.txt[]
+
 include::config/mailinfo.txt[]
 
 include::config/mailmap.txt[]

diff --git a/Documentation/config/init.txt b/Documentation/config/init.txt
index dc77f8c8446801fddbce2dff1ef4e678f431e202..79c79d66174ebd9f2dfb867a6a39a339529b7fc0 100644 (file)
--- a/Documentation/config/init.txt
+++ b/Documentation/config/init.txt
@@ -4,4 +4,4 @@ init.templateDir::
 
 init.defaultBranch::
        Allows overriding the default branch name e.g. when initializing
-       a new repository or when cloning an empty repository.
+       a new repository.

diff --git a/Documentation/config/lsrefs.txt b/Documentation/config/lsrefs.txt
new file mode 100644 (file)
index 0000000..adeda0f
--- /dev/null
+++ b/Documentation/config/lsrefs.txt
@@ -0,0 +1,9 @@
+lsrefs.unborn::
+       May be "advertise" (the default), "allow", or "ignore". If "advertise",
+       the server will respond to the client sending "unborn" (as described in
+       protocol-v2.txt) and will advertise support for this feature during the
+       protocol v2 capability advertisement. "allow" is the same as
+       "advertise" except that the server will not advertise support for this
+       feature; this is useful for load-balanced servers that cannot be
+       updated atomically (for example), since the administrator could
+       configure "allow", then after a delay, configure "advertise".

diff --git a/Documentation/technical/protocol-v2.txt b/Documentation/technical/protocol-v2.txt
index 85daeb5d9e77f8d597cb7ce7d842598133b7b2a6..f772d90eaf98cecde7b0c6ddb4c280980af5f13a 100644 (file)
--- a/Documentation/technical/protocol-v2.txt
+++ b/Documentation/technical/protocol-v2.txt
@@ -192,11 +192,20 @@ ls-refs takes in the following arguments:
        When specified, only references having a prefix matching one of
        the provided prefixes are displayed.
 
+If the 'unborn' feature is advertised the following argument can be
+included in the client's request.
+
+    unborn
+       The server will send information about HEAD even if it is a symref
+       pointing to an unborn branch in the form "unborn HEAD
+       symref-target:<target>".
+
 The output of ls-refs is as follows:
 
     output = *ref
             flush-pkt
-    ref = PKT-LINE(obj-id SP refname *(SP ref-attribute) LF)
+    obj-id-or-unborn = (obj-id | "unborn")
+    ref = PKT-LINE(obj-id-or-unborn SP refname *(SP ref-attribute) LF)
     ref-attribute = (symref | peeled)
     symref = "symref-target:" symref-target
     peeled = "peeled:" obj-id

diff --git a/builtin/clone.c b/builtin/clone.c
index e335734b4cfd32560b5d0cfa8a60426fa5c9514c..51e844a2de0a236f3ecd0305b3a5726aed80f5e6 100644 (file)
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -979,7 +979,8 @@ int cmd_clone(int argc, const char **argv, const char *prefix)
        int err = 0, complete_refs_before_fetch = 1;
        int submodule_progress;
 
-       struct strvec ref_prefixes = STRVEC_INIT;
+       struct transport_ls_refs_options transport_ls_refs_options =
+               TRANSPORT_LS_REFS_OPTIONS_INIT;
 
        packet_trace_identity("clone");
 
@@ -1257,14 +1258,17 @@ int cmd_clone(int argc, const char **argv, const char *prefix)
                transport->smart_options->check_self_contained_and_connected = 1;
 
 
-       strvec_push(&ref_prefixes, "HEAD");
-       refspec_ref_prefixes(&remote->fetch, &ref_prefixes);
+       strvec_push(&transport_ls_refs_options.ref_prefixes, "HEAD");
+       refspec_ref_prefixes(&remote->fetch,
+                            &transport_ls_refs_options.ref_prefixes);
        if (option_branch)
-               expand_ref_prefix(&ref_prefixes, option_branch);
+               expand_ref_prefix(&transport_ls_refs_options.ref_prefixes,
+                                 option_branch);
        if (!option_no_tags)
-               strvec_push(&ref_prefixes, "refs/tags/");
+               strvec_push(&transport_ls_refs_options.ref_prefixes,
+                           "refs/tags/");
 
-       refs = transport_get_remote_refs(transport, &ref_prefixes);
+       refs = transport_get_remote_refs(transport, &transport_ls_refs_options);
 
        if (refs) {
                int hash_algo = hash_algo_by_ptr(transport_get_hash_algo(transport));
@@ -1326,8 +1330,19 @@ int cmd_clone(int argc, const char **argv, const char *prefix)
                remote_head = NULL;
                option_no_checkout = 1;
                if (!option_bare) {
-                       const char *branch = git_default_branch_name(0);
-                       char *ref = xstrfmt("refs/heads/%s", branch);
+                       const char *branch;
+                       char *ref;
+
+                       if (transport_ls_refs_options.unborn_head_target &&
+                           skip_prefix(transport_ls_refs_options.unborn_head_target,
+                                       "refs/heads/", &branch)) {
+                               ref = transport_ls_refs_options.unborn_head_target;
+                               transport_ls_refs_options.unborn_head_target = NULL;
+                               create_symref("HEAD", ref, reflog_msg.buf);
+                       } else {
+                               branch = git_default_branch_name(0);
+                               ref = xstrfmt("refs/heads/%s", branch);
+                       }
 
                        install_branch_config(0, branch, remote_name, ref);
                        free(ref);
@@ -1380,6 +1395,7 @@ cleanup:
        strbuf_release(&key);
        junk_mode = JUNK_LEAVE_ALL;
 
-       strvec_clear(&ref_prefixes);
+       strvec_clear(&transport_ls_refs_options.ref_prefixes);
+       free(transport_ls_refs_options.unborn_head_target);
        return err;
 }

diff --git a/builtin/fetch-pack.c b/builtin/fetch-pack.c
index 58b7c1fbdc47b7f3bf866e1e9bcdf924a10e8033..c2d96f4c89ab0fa7207f74a17d0bdf94f8bd3780 100644 (file)
--- a/builtin/fetch-pack.c
+++ b/builtin/fetch-pack.c
@@ -220,7 +220,8 @@ int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
        version = discover_version(&reader);
        switch (version) {
        case protocol_v2:
-               get_remote_refs(fd[1], &reader, &ref, 0, NULL, NULL, args.stateless_rpc);
+               get_remote_refs(fd[1], &reader, &ref, 0, NULL, NULL,
+                               args.stateless_rpc);
                break;
        case protocol_v1:
        case protocol_v0:

diff --git a/builtin/fetch.c b/builtin/fetch.c
index 91f3d20696d37a4827872f735978a437e8d2b230..0b90de87c7a2ade9e11e67c8d59338eebdc131a7 100644 (file)
--- a/builtin/fetch.c
+++ b/builtin/fetch.c
@@ -1455,7 +1455,8 @@ static int do_fetch(struct transport *transport,
        int autotags = (transport->remote->fetch_tags == 1);
        int retcode = 0;
        const struct ref *remote_refs;
-       struct strvec ref_prefixes = STRVEC_INIT;
+       struct transport_ls_refs_options transport_ls_refs_options =
+               TRANSPORT_LS_REFS_OPTIONS_INIT;
        int must_list_refs = 1;
 
        if (tags == TAGS_DEFAULT) {
@@ -1475,7 +1476,7 @@ static int do_fetch(struct transport *transport,
        if (rs->nr) {
                int i;
 
-               refspec_ref_prefixes(rs, &ref_prefixes);
+               refspec_ref_prefixes(rs, &transport_ls_refs_options.ref_prefixes);
 
                /*
                 * We can avoid listing refs if all of them are exact
@@ -1489,22 +1490,25 @@ static int do_fetch(struct transport *transport,
                        }
                }
        } else if (transport->remote && transport->remote->fetch.nr)
-               refspec_ref_prefixes(&transport->remote->fetch, &ref_prefixes);
+               refspec_ref_prefixes(&transport->remote->fetch,
+                                    &transport_ls_refs_options.ref_prefixes);
 
        if (tags == TAGS_SET || tags == TAGS_DEFAULT) {
                must_list_refs = 1;
-               if (ref_prefixes.nr)
-                       strvec_push(&ref_prefixes, "refs/tags/");
+               if (transport_ls_refs_options.ref_prefixes.nr)
+                       strvec_push(&transport_ls_refs_options.ref_prefixes,
+                                   "refs/tags/");
        }
 
        if (must_list_refs) {
                trace2_region_enter("fetch", "remote_refs", the_repository);
-               remote_refs = transport_get_remote_refs(transport, &ref_prefixes);
+               remote_refs = transport_get_remote_refs(transport,
+                                                       &transport_ls_refs_options);
                trace2_region_leave("fetch", "remote_refs", the_repository);
        } else
                remote_refs = NULL;
 
-       strvec_clear(&ref_prefixes);
+       strvec_clear(&transport_ls_refs_options.ref_prefixes);
 
        ref_map = get_ref_map(transport->remote, remote_refs, rs,
                              tags, &autotags);

diff --git a/builtin/ls-remote.c b/builtin/ls-remote.c
index 092917eca29b76f27bce31cbf6a5fff562fae7f0..ef604752a044a48609a10ee90a8ca487c0acfb2d 100644 (file)
--- a/builtin/ls-remote.c
+++ b/builtin/ls-remote.c
@@ -45,7 +45,8 @@ int cmd_ls_remote(int argc, const char **argv, const char *prefix)
        int show_symref_target = 0;
        const char *uploadpack = NULL;
        const char **pattern = NULL;
-       struct strvec ref_prefixes = STRVEC_INIT;
+       struct transport_ls_refs_options transport_options =
+               TRANSPORT_LS_REFS_OPTIONS_INIT;
        int i;
        struct string_list server_options = STRING_LIST_INIT_DUP;
 
@@ -94,9 +95,9 @@ int cmd_ls_remote(int argc, const char **argv, const char *prefix)
        }
 
        if (flags & REF_TAGS)
-               strvec_push(&ref_prefixes, "refs/tags/");
+               strvec_push(&transport_options.ref_prefixes, "refs/tags/");
        if (flags & REF_HEADS)
-               strvec_push(&ref_prefixes, "refs/heads/");
+               strvec_push(&transport_options.ref_prefixes, "refs/heads/");
 
        remote = remote_get(dest);
        if (!remote) {
@@ -118,7 +119,7 @@ int cmd_ls_remote(int argc, const char **argv, const char *prefix)
        if (server_options.nr)
                transport->server_options = &server_options;
 
-       ref = transport_get_remote_refs(transport, &ref_prefixes);
+       ref = transport_get_remote_refs(transport, &transport_options);
        if (ref) {
                int hash_algo = hash_algo_by_ptr(transport_get_hash_algo(transport));
                repo_set_hash_algo(the_repository, hash_algo);

diff --git a/connect.c b/connect.c
index 9c97fee43031056dff2beb2a8fe9ed882e476c2d..40b5c15f811305648e22e0c2db55fbd1998cf211 100644 (file)
--- a/connect.c
+++ b/connect.c
@@ -376,7 +376,8 @@ struct ref **get_remote_heads(struct packet_reader *reader,
 }
 
 /* Returns 1 when a valid ref has been added to `list`, 0 otherwise */
-static int process_ref_v2(struct packet_reader *reader, struct ref ***list)
+static int process_ref_v2(struct packet_reader *reader, struct ref ***list,
+                         char **unborn_head_target)
 {
        int ret = 1;
        int i = 0;
@@ -397,6 +398,25 @@ static int process_ref_v2(struct packet_reader *reader, struct ref ***list)
                goto out;
        }
 
+       if (!strcmp("unborn", line_sections.items[i].string)) {
+               i++;
+               if (unborn_head_target &&
+                   !strcmp("HEAD", line_sections.items[i++].string)) {
+                       /*
+                        * Look for the symref target (if any). If found,
+                        * return it to the caller.
+                        */
+                       for (; i < line_sections.nr; i++) {
+                               const char *arg = line_sections.items[i].string;
+
+                               if (skip_prefix(arg, "symref-target:", &arg)) {
+                                       *unborn_head_target = xstrdup(arg);
+                                       break;
+                               }
+                       }
+               }
+               goto out;
+       }
        if (parse_oid_hex_algop(line_sections.items[i++].string, &old_oid, &end, reader->hash_algo) ||
            *end) {
                ret = 0;
@@ -453,12 +473,16 @@ void check_stateless_delimiter(int stateless_rpc,
 
 struct ref **get_remote_refs(int fd_out, struct packet_reader *reader,
                             struct ref **list, int for_push,
-                            const struct strvec *ref_prefixes,
+                            struct transport_ls_refs_options *transport_options,
                             const struct string_list *server_options,
                             int stateless_rpc)
 {
        int i;
        const char *hash_name;
+       struct strvec *ref_prefixes = transport_options ?
+               &transport_options->ref_prefixes : NULL;
+       char **unborn_head_target = transport_options ?
+               &transport_options->unborn_head_target : NULL;
        *list = NULL;
 
        if (server_supports_v2("ls-refs", 1))
@@ -488,6 +512,8 @@ struct ref **get_remote_refs(int fd_out, struct packet_reader *reader,
        if (!for_push)
                packet_write_fmt(fd_out, "peel\n");
        packet_write_fmt(fd_out, "symrefs\n");
+       if (server_supports_feature("ls-refs", "unborn", 0))
+               packet_write_fmt(fd_out, "unborn\n");
        for (i = 0; ref_prefixes && i < ref_prefixes->nr; i++) {
                packet_write_fmt(fd_out, "ref-prefix %s\n",
                                 ref_prefixes->v[i]);
@@ -496,7 +522,7 @@ struct ref **get_remote_refs(int fd_out, struct packet_reader *reader,
 
        /* Process response from server */
        while (packet_reader_read(reader) == PACKET_READ_NORMAL) {
-               if (!process_ref_v2(reader, &list))
+               if (!process_ref_v2(reader, &list, unborn_head_target))
                        die(_("invalid ls-refs response: %s"), reader->line);
        }
 

diff --git a/ls-refs.c b/ls-refs.c
index 5ff5473869fa19aa08d655cb1dcc7485d71dbbbd..88f6c3f60d8ef61373a1bfed33f49c877b6af320 100644 (file)
--- a/ls-refs.c
+++ b/ls-refs.c
@@ -7,6 +7,39 @@
 #include "pkt-line.h"
 #include "config.h"
 
+static int config_read;
+static int advertise_unborn;
+static int allow_unborn;
+
+static void ensure_config_read(void)
+{
+       const char *str = NULL;
+
+       if (config_read)
+               return;
+
+       if (repo_config_get_string_tmp(the_repository, "lsrefs.unborn", &str)) {
+               /*
+                * If there is no such config, advertise and allow it by
+                * default.
+                */
+               advertise_unborn = 1;
+               allow_unborn = 1;
+       } else {
+               if (!strcmp(str, "advertise")) {
+                       advertise_unborn = 1;
+                       allow_unborn = 1;
+               } else if (!strcmp(str, "allow")) {
+                       allow_unborn = 1;
+               } else if (!strcmp(str, "ignore")) {
+                       /* do nothing */
+               } else {
+                       die(_("invalid value '%s' for lsrefs.unborn"), str);
+               }
+       }
+       config_read = 1;
+}
+
 /*
  * Check if one of the prefixes is a prefix of the ref.
  * If no prefixes were provided, all refs match.
@@ -32,6 +65,7 @@ struct ls_refs_data {
        unsigned peel;
        unsigned symrefs;
        struct strvec prefixes;
+       unsigned unborn : 1;
 };
 
 static int send_ref(const char *refname, const struct object_id *oid,
@@ -47,7 +81,10 @@ static int send_ref(const char *refname, const struct object_id *oid,
        if (!ref_match(&data->prefixes, refname_nons))
                return 0;
 
-       strbuf_addf(&refline, "%s %s", oid_to_hex(oid), refname_nons);
+       if (oid)
+               strbuf_addf(&refline, "%s %s", oid_to_hex(oid), refname_nons);
+       else
+               strbuf_addf(&refline, "unborn %s", refname_nons);
        if (data->symrefs && flag & REF_ISSYMREF) {
                struct object_id unused;
                const char *symref_target = resolve_ref_unsafe(refname, 0,
@@ -61,7 +98,7 @@ static int send_ref(const char *refname, const struct object_id *oid,
                            strip_namespace(symref_target));
        }
 
-       if (data->peel) {
+       if (data->peel && oid) {
                struct object_id peeled;
                if (!peel_iterated_oid(oid, &peeled))
                        strbuf_addf(&refline, " peeled:%s", oid_to_hex(&peeled));
@@ -74,6 +111,23 @@ static int send_ref(const char *refname, const struct object_id *oid,
        return 0;
 }
 
+static void send_possibly_unborn_head(struct ls_refs_data *data)
+{
+       struct strbuf namespaced = STRBUF_INIT;
+       struct object_id oid;
+       int flag;
+       int oid_is_null;
+
+       strbuf_addf(&namespaced, "%sHEAD", get_git_namespace());
+       if (!resolve_ref_unsafe(namespaced.buf, 0, &oid, &flag))
+               return; /* bad ref */
+       oid_is_null = is_null_oid(&oid);
+       if (!oid_is_null ||
+           (data->unborn && data->symrefs && (flag & REF_ISSYMREF)))
+               send_ref(namespaced.buf, oid_is_null ? NULL : &oid, flag, data);
+       strbuf_release(&namespaced);
+}
+
 static int ls_refs_config(const char *var, const char *value, void *data)
 {
        /*
@@ -92,6 +146,7 @@ int ls_refs(struct repository *r, struct strvec *keys,
        memset(&data, 0, sizeof(data));
        strvec_init(&data.prefixes);
 
+       ensure_config_read();
        git_config(ls_refs_config, NULL);
 
        while (packet_reader_read(request) == PACKET_READ_NORMAL) {
@@ -104,12 +159,14 @@ int ls_refs(struct repository *r, struct strvec *keys,
                        data.symrefs = 1;
                else if (skip_prefix(arg, "ref-prefix ", &out))
                        strvec_push(&data.prefixes, out);
+               else if (!strcmp("unborn", arg))
+                       data.unborn = allow_unborn;
        }
 
        if (request->status != PACKET_READ_FLUSH)
                die(_("expected flush after ls-refs arguments"));
 
-       head_ref_namespaced(send_ref, &data);
+       send_possibly_unborn_head(&data);
        if (!data.prefixes.nr)
                strvec_push(&data.prefixes, "");
        for_each_fullref_in_prefixes(get_git_namespace(), data.prefixes.v,
@@ -118,3 +175,14 @@ int ls_refs(struct repository *r, struct strvec *keys,
        strvec_clear(&data.prefixes);
        return 0;
 }
+
+int ls_refs_advertise(struct repository *r, struct strbuf *value)
+{
+       if (value) {
+               ensure_config_read();
+               if (advertise_unborn)
+                       strbuf_addstr(value, "unborn");
+       }
+
+       return 1;
+}

diff --git a/ls-refs.h b/ls-refs.h
index 7b33a7c6b819c0d504ad6b447b61e003e9f590fb..a99e4be0bdde1b287807459dc40934ef4459b227 100644 (file)
--- a/ls-refs.h
+++ b/ls-refs.h
@@ -6,5 +6,6 @@ struct strvec;
 struct packet_reader;
 int ls_refs(struct repository *r, struct strvec *keys,
            struct packet_reader *request);
+int ls_refs_advertise(struct repository *r, struct strbuf *value);
 
 #endif /* LS_REFS_H */

diff --git a/remote.h b/remote.h
index aad1a0f0808b44ddbfa8b17562cc8636ac2ac28e..5a5919825285745ff11f5a8f7248ebaaddd0560a 100644 (file)
--- a/remote.h
+++ b/remote.h
@@ -6,6 +6,8 @@
 #include "hashmap.h"
 #include "refspec.h"
 
+struct transport_ls_refs_options;
+
 /**
  * The API gives access to the configuration related to remotes. It handles
  * all three configuration mechanisms historically and currently used by Git,
@@ -196,7 +198,7 @@ struct ref **get_remote_heads(struct packet_reader *reader,
 /* Used for protocol v2 in order to retrieve refs from a remote */
 struct ref **get_remote_refs(int fd_out, struct packet_reader *reader,
                             struct ref **list, int for_push,
-                            const struct strvec *ref_prefixes,
+                            struct transport_ls_refs_options *transport_options,
                             const struct string_list *server_options,
                             int stateless_rpc);
 

diff --git a/serve.c b/serve.c
index eec2fe6f294cd1c0c5e8a76b66b09d78dd4e22da..ac20c7276304c51a2169e3d95777a05a1d6c1e31 100644 (file)
--- a/serve.c
+++ b/serve.c
@@ -73,7 +73,7 @@ struct protocol_capability {
 
 static struct protocol_capability capabilities[] = {
        { "agent", agent_advertise, NULL },
-       { "ls-refs", always_advertise, ls_refs },
+       { "ls-refs", ls_refs_advertise, ls_refs },
        { "fetch", upload_pack_advertise, upload_pack_v2 },
        { "server-option", always_advertise, NULL },
        { "object-format", object_format_advertise, NULL },

diff --git a/t/t5606-clone-options.sh b/t/t5606-clone-options.sh
index 5d6e63a841f7f2f64a0fa857261264c4bd924c67..52e5789fb050d74db72d1ad62dab1cce5ba97793 100755 (executable)
--- a/t/t5606-clone-options.sh
+++ b/t/t5606-clone-options.sh
@@ -105,11 +105,13 @@ test_expect_success 'redirected clone -v does show progress' '
 '
 
 test_expect_success 'chooses correct default initial branch name' '
-       git init --bare empty &&
+       GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
+       git -c init.defaultBranch=foo init --bare empty &&
+       test_config -C empty lsrefs.unborn advertise &&
        GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
        git -c init.defaultBranch=up clone empty whats-up &&
-       test refs/heads/up = $(git -C whats-up symbolic-ref HEAD) &&
-       test refs/heads/up = $(git -C whats-up config branch.up.merge)
+       test refs/heads/foo = $(git -C whats-up symbolic-ref HEAD) &&
+       test refs/heads/foo = $(git -C whats-up config branch.foo.merge)
 '
 
 test_expect_success 'guesses initial branch name correctly' '

diff --git a/t/t5701-git-serve.sh b/t/t5701-git-serve.sh
index d9143b4bd2d7ca27dd689c231774b8d143baa798..509f379d4920605e567646692c15146fd977b2cd 100755 (executable)
--- a/t/t5701-git-serve.sh
+++ b/t/t5701-git-serve.sh
@@ -15,7 +15,7 @@ test_expect_success 'test capability advertisement' '
        cat >expect <<-EOF &&
        version 2
        agent=git/$(git version | cut -d" " -f3)
-       ls-refs
+       ls-refs=unborn
        fetch=shallow
        server-option
        object-format=$(test_oid algo)

diff --git a/t/t5702-protocol-v2.sh b/t/t5702-protocol-v2.sh
index e8f0b4a299ea6afade7a2fc941776c6896de0849..9113d209c5145b93c1304d17715568afe1fd0fa6 100755 (executable)
--- a/t/t5702-protocol-v2.sh
+++ b/t/t5702-protocol-v2.sh
@@ -212,6 +212,31 @@ test_expect_success 'clone with file:// using protocol v2' '
        grep "ref-prefix refs/tags/" log
 '
 
+test_expect_success 'clone of empty repo propagates name of default branch' '
+       test_when_finished "rm -rf file_empty_parent file_empty_child" &&
+
+       GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
+       git -c init.defaultBranch=mydefaultbranch init file_empty_parent &&
+
+       GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
+       git -c init.defaultBranch=main -c protocol.version=2 \
+               clone "file://$(pwd)/file_empty_parent" file_empty_child &&
+       grep "refs/heads/mydefaultbranch" file_empty_child/.git/HEAD
+'
+
+test_expect_success '...but not if explicitly forbidden by config' '
+       test_when_finished "rm -rf file_empty_parent file_empty_child" &&
+
+       GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
+       git -c init.defaultBranch=mydefaultbranch init file_empty_parent &&
+       test_config -C file_empty_parent lsrefs.unborn ignore &&
+
+       GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
+       git -c init.defaultBranch=main -c protocol.version=2 \
+               clone "file://$(pwd)/file_empty_parent" file_empty_child &&
+       ! grep "refs/heads/mydefaultbranch" file_empty_child/.git/HEAD
+'
+
 test_expect_success 'fetch with file:// using protocol v2' '
        test_when_finished "rm -f log" &&
 

diff --git a/transport-helper.c b/transport-helper.c
index 5f6e0b3bd874dba714c107dffebd423ef25d10b4..49b7fb4dcb9a3012a9bdc60bc6fa581a47875e07 100644 (file)
--- a/transport-helper.c
+++ b/transport-helper.c
@@ -1162,13 +1162,14 @@ static int has_attribute(const char *attrs, const char *attr)
 }
 
 static struct ref *get_refs_list(struct transport *transport, int for_push,
-                                const struct strvec *ref_prefixes)
+                                struct transport_ls_refs_options *transport_options)
 {
        get_helper(transport);
 
        if (process_connect(transport, for_push)) {
                do_take_over(transport);
-               return transport->vtable->get_refs_list(transport, for_push, ref_prefixes);
+               return transport->vtable->get_refs_list(transport, for_push,
+                                                       transport_options);
        }
 
        return get_refs_list_using_list(transport, for_push);

diff --git a/transport-internal.h b/transport-internal.h
index 27c9daffc47ac95b2070006f570373c14cd4aa22..b60f1ba9077d09c5f0c3259fe5bc86c5facdbc78 100644 (file)
--- a/transport-internal.h
+++ b/transport-internal.h
@@ -4,6 +4,7 @@
 struct ref;
 struct transport;
 struct strvec;
+struct transport_ls_refs_options;
 
 struct transport_vtable {
        /**
@@ -18,19 +19,12 @@ struct transport_vtable {
         * the transport to try to share connections, for_push is a
         * hint as to whether the ultimate operation is a push or a fetch.
         *
-        * If communicating using protocol v2 a list of prefixes can be
-        * provided to be sent to the server to enable it to limit the ref
-        * advertisement.  Since ref filtering is done on the server's end, and
-        * only when using protocol v2, this list will be ignored when not
-        * using protocol v2 meaning this function can return refs which don't
-        * match the provided ref_prefixes.
-        *
         * If the transport is able to determine the remote hash for
         * the ref without a huge amount of effort, it should store it
         * in the ref's old_sha1 field; otherwise it should be all 0.
         **/
        struct ref *(*get_refs_list)(struct transport *transport, int for_push,
-                                    const struct strvec *ref_prefixes);
+                                    struct transport_ls_refs_options *transport_options);
 
        /**
         * Fetch the objects for the given refs. Note that this gets

diff --git a/transport.c b/transport.c
index 679a35e7c1b6168d3b8fc93f72ec9a50178d894c..b13fab5dc3b1b90933b77f15fe87ca422cc70784 100644 (file)
--- a/transport.c
+++ b/transport.c
@@ -127,7 +127,7 @@ struct bundle_transport_data {
 
 static struct ref *get_refs_from_bundle(struct transport *transport,
                                        int for_push,
-                                       const struct strvec *ref_prefixes)
+                                       struct transport_ls_refs_options *transport_options)
 {
        struct bundle_transport_data *data = transport->data;
        struct ref *result = NULL;
@@ -280,7 +280,7 @@ static void die_if_server_options(struct transport *transport)
  * remote refs.
  */
 static struct ref *handshake(struct transport *transport, int for_push,
-                            const struct strvec *ref_prefixes,
+                            struct transport_ls_refs_options *options,
                             int must_list_refs)
 {
        struct git_transport_data *data = transport->data;
@@ -303,7 +303,7 @@ static struct ref *handshake(struct transport *transport, int for_push,
                        trace2_data_string("transfer", NULL, "server-sid", server_sid);
                if (must_list_refs)
                        get_remote_refs(data->fd[1], &reader, &refs, for_push,
-                                       ref_prefixes,
+                                       options,
                                        transport->server_options,
                                        transport->stateless_rpc);
                break;
@@ -334,9 +334,9 @@ static struct ref *handshake(struct transport *transport, int for_push,
 }
 
 static struct ref *get_refs_via_connect(struct transport *transport, int for_push,
-                                       const struct strvec *ref_prefixes)
+                                       struct transport_ls_refs_options *options)
 {
-       return handshake(transport, for_push, ref_prefixes, 1);
+       return handshake(transport, for_push, options, 1);
 }
 
 static int fetch_refs_via_pack(struct transport *transport,
@@ -1252,19 +1252,20 @@ int transport_push(struct repository *r,
                int porcelain = flags & TRANSPORT_PUSH_PORCELAIN;
                int pretend = flags & TRANSPORT_PUSH_DRY_RUN;
                int push_ret, ret, err;
-               struct strvec ref_prefixes = STRVEC_INIT;
+               struct transport_ls_refs_options transport_options =
+                       TRANSPORT_LS_REFS_OPTIONS_INIT;
 
                if (check_push_refs(local_refs, rs) < 0)
                        return -1;
 
-               refspec_ref_prefixes(rs, &ref_prefixes);
+               refspec_ref_prefixes(rs, &transport_options.ref_prefixes);
 
                trace2_region_enter("transport_push", "get_refs_list", r);
                remote_refs = transport->vtable->get_refs_list(transport, 1,
-                                                              &ref_prefixes);
+                                                              &transport_options);
                trace2_region_leave("transport_push", "get_refs_list", r);
 
-               strvec_clear(&ref_prefixes);
+               strvec_clear(&transport_options.ref_prefixes);
 
                if (flags & TRANSPORT_PUSH_ALL)
                        match_flags |= MATCH_REFS_ALL;
@@ -1380,12 +1381,12 @@ int transport_push(struct repository *r,
 }
 
 const struct ref *transport_get_remote_refs(struct transport *transport,
-                                           const struct strvec *ref_prefixes)
+                                           struct transport_ls_refs_options *transport_options)
 {
        if (!transport->got_remote_refs) {
                transport->remote_refs =
                        transport->vtable->get_refs_list(transport, 0,
-                                                        ref_prefixes);
+                                                        transport_options);
                transport->got_remote_refs = 1;
        }
 

diff --git a/transport.h b/transport.h
index 24558c027d61bba1dd99b17a1c9d1cd484b1cb8a..24e15799e714aeb53f725b161a14172202cbae7e 100644 (file)
--- a/transport.h
+++ b/transport.h
@@ -233,17 +233,32 @@ int transport_push(struct repository *repo,
                   struct refspec *rs, int flags,
                   unsigned int * reject_reasons);
 
+struct transport_ls_refs_options {
+       /*
+        * Optionally, a list of ref prefixes can be provided which can be sent
+        * to the server (when communicating using protocol v2) to enable it to
+        * limit the ref advertisement.  Since ref filtering is done on the
+        * server's end (and only when using protocol v2),
+        * transport_get_remote_refs() could return refs which don't match the
+        * provided ref_prefixes.
+        */
+       struct strvec ref_prefixes;
+
+       /*
+        * If unborn_head_target is not NULL, and the remote reports HEAD as
+        * pointing to an unborn branch, transport_get_remote_refs() stores the
+        * unborn branch in unborn_head_target. It should be freed by the
+        * caller.
+        */
+       char *unborn_head_target;
+};
+#define TRANSPORT_LS_REFS_OPTIONS_INIT { STRVEC_INIT }
+
 /*
  * Retrieve refs from a remote.
- *
- * Optionally a list of ref prefixes can be provided which can be sent to the
- * server (when communicating using protocol v2) to enable it to limit the ref
- * advertisement.  Since ref filtering is done on the server's end (and only
- * when using protocol v2), this can return refs which don't match the provided
- * ref_prefixes.
  */
 const struct ref *transport_get_remote_refs(struct transport *transport,
-                                           const struct strvec *ref_prefixes);
+                                           struct transport_ls_refs_options *transport_options);
 
 /*
  * Fetch the hash algorithm used by a remote.