undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

connect: convert get_remote_heads to use struct packet_reader

Browse Source 
In order to allow for better control flow when protocol_v2 is introduced
convert 'get_remote_heads()' to use 'struct packet_reader' to read
packet lines.  This enables a client to be able to peek the first line
of a server's response (without consuming it) in order to determine the
protocol version its speaking and then passing control to the
appropriate handler.

This is needed because the initial response from a server speaking
protocol_v0 includes the first ref, while subsequent protocol versions
respond with a version line.  We want to be able to read this first line
without consuming the first ref sent in the protocol_v0 case so that the
protocol version the server is speaking can be determined outside of
'get_remote_heads()' in a future patch.

Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Brandon Williams 2018-03-14 11:31:44 -07:00 committed by Junio C Hamano
parent 635365eb2f
commit 7e3e479b90
1 changed files with 95 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

173
connect.c
View File

@ -48,6 +48,12 @@ int check_ref_type(const struct ref *ref, int flags)
static void die_initial_contact(int unexpected) static void die_initial_contact(int unexpected)
{ {
/*
* 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.
*/
if (unexpected) if (unexpected)
die(_("The remote end hung up upon initial contact")); die(_("The remote end hung up upon initial contact"));
else else
@ -56,6 +62,40 @@ static void die_initial_contact(int unexpected)
"and the repository exists.")); "and the repository exists."));
} }
static enum protocol_version discover_version(struct packet_reader *reader)
{
enum protocol_version version = protocol_unknown_version;
/*
* Peek the first line of the server's response to
* determine the protocol version the server is speaking.
*/
switch (packet_reader_peek(reader)) {
case PACKET_READ_EOF:
die_initial_contact(0);
case PACKET_READ_FLUSH:
case PACKET_READ_DELIM:
version = protocol_v0;
break;
case PACKET_READ_NORMAL:
version = determine_protocol_version_client(reader->line);
break;
}
switch (version) {
case protocol_v1:
/* Read the peeked version line */
packet_reader_read(reader);
break;
case protocol_v0:
break;
case protocol_unknown_version:
BUG("unknown protocol version");
}
return version;
}
static void parse_one_symref_info(struct string_list *symref, const char *val, int len) static void parse_one_symref_info(struct string_list *symref, const char *val, int len)
{ {
char *sym, *target; char *sym, *target;
@ -109,60 +149,21 @@ static void annotate_refs_with_symref_info(struct ref *ref)
string_list_clear(&symref, 0); string_list_clear(&symref, 0);
} }
/* static void process_capabilities(const char *line, int *len)
* Read one line of a server's ref advertisement into packet_buffer.
*/
static int read_remote_ref(int in, char **src_buf, size_t *src_len,
int *responded)
{ {
int len = packet_read(in, src_buf, src_len, int nul_location = strlen(line);
packet_buffer, sizeof(packet_buffer),
PACKET_READ_GENTLE_ON_EOF |
PACKET_READ_CHOMP_NEWLINE);
const char *arg;
if (len < 0)
die_initial_contact(*responded);
if (len > 4 && skip_prefix(packet_buffer, "ERR ", &arg))
die("remote error: %s", arg);
*responded = 1;
return len;
}
#define EXPECTING_PROTOCOL_VERSION 0
#define EXPECTING_FIRST_REF 1
#define EXPECTING_REF 2
#define EXPECTING_SHALLOW 3
/* Returns 1 if packet_buffer is a protocol version pkt-line, 0 otherwise. */
static int process_protocol_version(void)
{
switch (determine_protocol_version_client(packet_buffer)) {
case protocol_v1:
return 1;
case protocol_v0:
return 0;
default:
die("server is speaking an unknown protocol");
}
}
static void process_capabilities(int *len)
{
int nul_location = strlen(packet_buffer);
if (nul_location == *len) if (nul_location == *len)
return; return;
server_capabilities = xstrdup(packet_buffer + nul_location + 1); server_capabilities = xstrdup(line + nul_location + 1);
*len = nul_location; *len = nul_location;
} }
static int process_dummy_ref(void) static int process_dummy_ref(const char *line)
{ {
struct object_id oid; struct object_id oid;
const char *name; const char *name;
if (parse_oid_hex(packet_buffer, &oid, &name)) if (parse_oid_hex(line, &oid, &name))
return 0; return 0;
if (*name != ' ') if (*name != ' ')
return 0; return 0;
@ -171,20 +172,20 @@ static int process_dummy_ref(void)
return !oidcmp(&null_oid, &oid) && !strcmp(name, "capabilities^{}"); return !oidcmp(&null_oid, &oid) && !strcmp(name, "capabilities^{}");
} }
static void check_no_capabilities(int len) static void check_no_capabilities(const char *line, int len)
{ {
if (strlen(packet_buffer) != len) if (strlen(line) != len)
warning("Ignoring capabilities after first line '%s'", warning("Ignoring capabilities after first line '%s'",
packet_buffer + strlen(packet_buffer)); line + strlen(line));
} }
static int process_ref(int len, struct ref ***list, unsigned int flags, static int process_ref(const char *line, int len, struct ref ***list,
struct oid_array *extra_have) unsigned int flags, struct oid_array *extra_have)
{ {
struct object_id old_oid; struct object_id old_oid;
const char *name; const char *name;
if (parse_oid_hex(packet_buffer, &old_oid, &name)) if (parse_oid_hex(line, &old_oid, &name))
return 0; return 0;
if (*name != ' ') if (*name != ' ')
return 0; return 0;
@ -200,16 +201,17 @@ static int process_ref(int len, struct ref ***list, unsigned int flags,
**list = ref; **list = ref;
*list = &ref->next; *list = &ref->next;
} }
check_no_capabilities(len); check_no_capabilities(line, len);
return 1; return 1;
} }
static int process_shallow(int len, struct oid_array *shallow_points) static int process_shallow(const char *line, int len,
struct oid_array *shallow_points)
{ {
const char *arg; const char *arg;
struct object_id old_oid; struct object_id old_oid;
if (!skip_prefix(packet_buffer, "shallow ", &arg)) if (!skip_prefix(line, "shallow ", &arg))
return 0; return 0;
if (get_oid_hex(arg, &old_oid)) if (get_oid_hex(arg, &old_oid))
@ -217,10 +219,17 @@ static int process_shallow(int len, struct oid_array *shallow_points)
if (!shallow_points) if (!shallow_points)
die("repository on the other end cannot be shallow"); die("repository on the other end cannot be shallow");
oid_array_append(shallow_points, &old_oid); oid_array_append(shallow_points, &old_oid);
check_no_capabilities(len); check_no_capabilities(line, len);
return 1; return 1;
} }
enum get_remote_heads_state {
EXPECTING_FIRST_REF = 0,
EXPECTING_REF,
EXPECTING_SHALLOW,
EXPECTING_DONE,
};
/* /*
* Read all the refs from the other end * Read all the refs from the other end
*/ */
@ -230,47 +239,55 @@ struct ref **get_remote_heads(int in, char *src_buf, size_t src_len,
struct oid_array *shallow_points) struct oid_array *shallow_points)
{ {
struct ref **orig_list = list; struct ref **orig_list = list;
int len = 0;
enum get_remote_heads_state state = EXPECTING_FIRST_REF;
struct packet_reader reader;
const char *arg;
/* packet_reader_init(&reader, in, src_buf, src_len,
* A hang-up after seeing some response from the other end PACKET_READ_CHOMP_NEWLINE |
* means that it is unexpected, as we know the other end is PACKET_READ_GENTLE_ON_EOF);
* willing to talk to us. A hang-up before seeing any
* response does not necessarily mean an ACL problem, though. discover_version(&reader);
*/
int responded = 0;
int len;
int state = EXPECTING_PROTOCOL_VERSION;
*list = NULL; *list = NULL;
while ((len = read_remote_ref(in, &src_buf, &src_len, &responded))) { while (state != EXPECTING_DONE) {
switch (packet_reader_read(&reader)) {
case PACKET_READ_EOF:
die_initial_contact(1);
case PACKET_READ_NORMAL:
len = reader.pktlen;
if (len > 4 && skip_prefix(reader.line, "ERR ", &arg))
die("remote error: %s", arg);
break;
case PACKET_READ_FLUSH:
state = EXPECTING_DONE;
break;
case PACKET_READ_DELIM:
die("invalid packet");
}
switch (state) { switch (state) {
case EXPECTING_PROTOCOL_VERSION:
if (process_protocol_version()) {
state = EXPECTING_FIRST_REF;
break;
}
state = EXPECTING_FIRST_REF;
/* fallthrough */
case EXPECTING_FIRST_REF: case EXPECTING_FIRST_REF:
process_capabilities(&len); process_capabilities(reader.line, &len);
if (process_dummy_ref()) { if (process_dummy_ref(reader.line)) {
state = EXPECTING_SHALLOW; state = EXPECTING_SHALLOW;
break; break;
} }
state = EXPECTING_REF; state = EXPECTING_REF;
/* fallthrough */ /* fallthrough */
case EXPECTING_REF: case EXPECTING_REF:
if (process_ref(len, &list, flags, extra_have)) if (process_ref(reader.line, len, &list, flags, extra_have))
break; break;
state = EXPECTING_SHALLOW; state = EXPECTING_SHALLOW;
/* fallthrough */ /* fallthrough */
case EXPECTING_SHALLOW: case EXPECTING_SHALLOW:
if (process_shallow(len, shallow_points)) if (process_shallow(reader.line, len, shallow_points))
break; break;
die("protocol error: unexpected '%s'", packet_buffer); die("protocol error: unexpected '%s'", reader.line);
default: case EXPECTING_DONE:
die("unexpected state %d", state); break;
} }
} }