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
pull/967/head
Junio C Hamano 2 years ago
commit 69571dfe21
  1. 2
      Documentation/config.txt
  2. 2
      Documentation/config/init.txt
  3. 9
      Documentation/config/lsrefs.txt
  4. 11
      Documentation/technical/protocol-v2.txt
  5. 34
      builtin/clone.c
  6. 3
      builtin/fetch-pack.c
  7. 18
      builtin/fetch.c
  8. 9
      builtin/ls-remote.c
  9. 32
      connect.c
  10. 74
      ls-refs.c
  11. 1
      ls-refs.h
  12. 4
      remote.h
  13. 2
      serve.c
  14. 8
      t/t5606-clone-options.sh
  15. 2
      t/t5701-git-serve.sh
  16. 25
      t/t5702-protocol-v2.sh
  17. 5
      transport-helper.c
  18. 10
      transport-internal.h
  19. 23
      transport.c
  20. 29
      transport.h

@ -398,6 +398,8 @@ include::config/interactive.txt[]
include::config/log.txt[]
include::config/lsrefs.txt[]
include::config/mailinfo.txt[]
include::config/mailmap.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.

@ -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".

@ -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

@ -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;
}

@ -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:

@ -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);

@ -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);

@ -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);
}

@ -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;
}

@ -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 */

@ -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);

@ -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 },

@ -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' '

@ -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)

@ -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" &&

@ -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);

@ -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

@ -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;
}

@ -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.

Loading…
Cancel
Save