mirror of
https://github.com/git/git
synced 2024-08-25 02:35:46 +00:00
![Brandon Williams](/assets/img/avatar_default.png)
When communicating with a v2 server, perform a fetch by requesting the 'fetch' command. Signed-off-by: Brandon Williams <bmwill@google.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
258 lines
6.2 KiB
C
258 lines
6.2 KiB
C
#include "cache.h"
|
|
#include "repository.h"
|
|
#include "config.h"
|
|
#include "pkt-line.h"
|
|
#include "version.h"
|
|
#include "argv-array.h"
|
|
#include "ls-refs.h"
|
|
#include "serve.h"
|
|
#include "upload-pack.h"
|
|
|
|
static int always_advertise(struct repository *r,
|
|
struct strbuf *value)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static int agent_advertise(struct repository *r,
|
|
struct strbuf *value)
|
|
{
|
|
if (value)
|
|
strbuf_addstr(value, git_user_agent_sanitized());
|
|
return 1;
|
|
}
|
|
|
|
struct protocol_capability {
|
|
/*
|
|
* The name of the capability. The server uses this name when
|
|
* advertising this capability, and the client uses this name to
|
|
* specify this capability.
|
|
*/
|
|
const char *name;
|
|
|
|
/*
|
|
* Function queried to see if a capability should be advertised.
|
|
* Optionally a value can be specified by adding it to 'value'.
|
|
* If a value is added to 'value', the server will advertise this
|
|
* capability as "<name>=<value>" instead of "<name>".
|
|
*/
|
|
int (*advertise)(struct repository *r, struct strbuf *value);
|
|
|
|
/*
|
|
* Function called when a client requests the capability as a command.
|
|
* The function will be provided the capabilities requested via 'keys'
|
|
* as well as a struct packet_reader 'request' which the command should
|
|
* use to read the command specific part of the request. Every command
|
|
* MUST read until a flush packet is seen before sending a response.
|
|
*
|
|
* This field should be NULL for capabilities which are not commands.
|
|
*/
|
|
int (*command)(struct repository *r,
|
|
struct argv_array *keys,
|
|
struct packet_reader *request);
|
|
};
|
|
|
|
static struct protocol_capability capabilities[] = {
|
|
{ "agent", agent_advertise, NULL },
|
|
{ "ls-refs", always_advertise, ls_refs },
|
|
{ "fetch", upload_pack_advertise, upload_pack_v2 },
|
|
};
|
|
|
|
static void advertise_capabilities(void)
|
|
{
|
|
struct strbuf capability = STRBUF_INIT;
|
|
struct strbuf value = STRBUF_INIT;
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(capabilities); i++) {
|
|
struct protocol_capability *c = &capabilities[i];
|
|
|
|
if (c->advertise(the_repository, &value)) {
|
|
strbuf_addstr(&capability, c->name);
|
|
|
|
if (value.len) {
|
|
strbuf_addch(&capability, '=');
|
|
strbuf_addbuf(&capability, &value);
|
|
}
|
|
|
|
strbuf_addch(&capability, '\n');
|
|
packet_write(1, capability.buf, capability.len);
|
|
}
|
|
|
|
strbuf_reset(&capability);
|
|
strbuf_reset(&value);
|
|
}
|
|
|
|
packet_flush(1);
|
|
strbuf_release(&capability);
|
|
strbuf_release(&value);
|
|
}
|
|
|
|
static struct protocol_capability *get_capability(const char *key)
|
|
{
|
|
int i;
|
|
|
|
if (!key)
|
|
return NULL;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(capabilities); i++) {
|
|
struct protocol_capability *c = &capabilities[i];
|
|
const char *out;
|
|
if (skip_prefix(key, c->name, &out) && (!*out || *out == '='))
|
|
return c;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static int is_valid_capability(const char *key)
|
|
{
|
|
const struct protocol_capability *c = get_capability(key);
|
|
|
|
return c && c->advertise(the_repository, NULL);
|
|
}
|
|
|
|
static int is_command(const char *key, struct protocol_capability **command)
|
|
{
|
|
const char *out;
|
|
|
|
if (skip_prefix(key, "command=", &out)) {
|
|
struct protocol_capability *cmd = get_capability(out);
|
|
|
|
if (*command)
|
|
die("command '%s' requested after already requesting command '%s'",
|
|
out, (*command)->name);
|
|
if (!cmd || !cmd->advertise(the_repository, NULL) || !cmd->command)
|
|
die("invalid command '%s'", out);
|
|
|
|
*command = cmd;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int has_capability(const struct argv_array *keys, const char *capability,
|
|
const char **value)
|
|
{
|
|
int i;
|
|
for (i = 0; i < keys->argc; i++) {
|
|
const char *out;
|
|
if (skip_prefix(keys->argv[i], capability, &out) &&
|
|
(!*out || *out == '=')) {
|
|
if (value) {
|
|
if (*out == '=')
|
|
out++;
|
|
*value = out;
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
enum request_state {
|
|
PROCESS_REQUEST_KEYS,
|
|
PROCESS_REQUEST_DONE,
|
|
};
|
|
|
|
static int process_request(void)
|
|
{
|
|
enum request_state state = PROCESS_REQUEST_KEYS;
|
|
struct packet_reader reader;
|
|
struct argv_array keys = ARGV_ARRAY_INIT;
|
|
struct protocol_capability *command = NULL;
|
|
|
|
packet_reader_init(&reader, 0, NULL, 0,
|
|
PACKET_READ_CHOMP_NEWLINE |
|
|
PACKET_READ_GENTLE_ON_EOF);
|
|
|
|
/*
|
|
* Check to see if the client closed their end before sending another
|
|
* request. If so we can terminate the connection.
|
|
*/
|
|
if (packet_reader_peek(&reader) == PACKET_READ_EOF)
|
|
return 1;
|
|
reader.options = PACKET_READ_CHOMP_NEWLINE;
|
|
|
|
while (state != PROCESS_REQUEST_DONE) {
|
|
switch (packet_reader_peek(&reader)) {
|
|
case PACKET_READ_EOF:
|
|
BUG("Should have already died when seeing EOF");
|
|
case PACKET_READ_NORMAL:
|
|
/* collect request; a sequence of keys and values */
|
|
if (is_command(reader.line, &command) ||
|
|
is_valid_capability(reader.line))
|
|
argv_array_push(&keys, reader.line);
|
|
else
|
|
die("unknown capability '%s'", reader.line);
|
|
|
|
/* Consume the peeked line */
|
|
packet_reader_read(&reader);
|
|
break;
|
|
case PACKET_READ_FLUSH:
|
|
/*
|
|
* If no command and no keys were given then the client
|
|
* wanted to terminate the connection.
|
|
*/
|
|
if (!keys.argc)
|
|
return 1;
|
|
|
|
/*
|
|
* The flush packet isn't consume here like it is in
|
|
* the other parts of this switch statement. This is
|
|
* so that the command can read the flush packet and
|
|
* see the end of the request in the same way it would
|
|
* if command specific arguments were provided after a
|
|
* delim packet.
|
|
*/
|
|
state = PROCESS_REQUEST_DONE;
|
|
break;
|
|
case PACKET_READ_DELIM:
|
|
/* Consume the peeked line */
|
|
packet_reader_read(&reader);
|
|
|
|
state = PROCESS_REQUEST_DONE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!command)
|
|
die("no command requested");
|
|
|
|
command->command(the_repository, &keys, &reader);
|
|
|
|
argv_array_clear(&keys);
|
|
return 0;
|
|
}
|
|
|
|
/* Main serve loop for protocol version 2 */
|
|
void serve(struct serve_options *options)
|
|
{
|
|
if (options->advertise_capabilities || !options->stateless_rpc) {
|
|
/* serve by default supports v2 */
|
|
packet_write_fmt(1, "version 2\n");
|
|
|
|
advertise_capabilities();
|
|
/*
|
|
* If only the list of capabilities was requested exit
|
|
* immediately after advertising capabilities
|
|
*/
|
|
if (options->advertise_capabilities)
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If stateless-rpc was requested then exit after
|
|
* a single request/response exchange
|
|
*/
|
|
if (options->stateless_rpc) {
|
|
process_request();
|
|
} else {
|
|
for (;;)
|
|
if (process_request())
|
|
break;
|
|
}
|
|
}
|