static int fetch_fsck_objects = -1;
static int transfer_fsck_objects = -1;
static int agent_supported;
-static struct fetch_pack_args args = {
- /* .uploadpack = */ "git-upload-pack",
-};
static const char fetch_pack_usage[] =
"git fetch-pack [--all] [--stdin] [--quiet|-q] [--keep|-k] [--thin] "
ACK_ready
};
-static void consume_shallow_list(int fd)
+static void consume_shallow_list(struct fetch_pack_args *args, int fd)
{
- if (args.stateless_rpc && args.depth > 0) {
+ if (args->stateless_rpc && args->depth > 0) {
/* If we sent a depth we will get back "duplicate"
* shallow and unshallow commands every time there
* is a block of have lines exchanged.
die("git fetch_pack: expected ACK/NAK, got '%s'", line);
}
-static void send_request(int fd, struct strbuf *buf)
+static void send_request(struct fetch_pack_args *args,
+ int fd, struct strbuf *buf)
{
- if (args.stateless_rpc) {
+ if (args->stateless_rpc) {
send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
packet_flush(fd);
} else
#define PIPESAFE_FLUSH 32
#define LARGE_FLUSH 1024
-static int next_flush(int count)
+static int next_flush(struct fetch_pack_args *args, int count)
{
- int flush_limit = args.stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
+ int flush_limit = args->stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
if (count < flush_limit)
count <<= 1;
return count;
}
-static int find_common(int fd[2], unsigned char *result_sha1,
+static int find_common(struct fetch_pack_args *args,
+ int fd[2], unsigned char *result_sha1,
struct ref *refs)
{
int fetching;
struct strbuf req_buf = STRBUF_INIT;
size_t state_len = 0;
- if (args.stateless_rpc && multi_ack == 1)
+ if (args->stateless_rpc && multi_ack == 1)
die("--stateless-rpc requires multi_ack_detailed");
if (marked)
for_each_ref(clear_marks, NULL);
if (no_done) strbuf_addstr(&c, " no-done");
if (use_sideband == 2) strbuf_addstr(&c, " side-band-64k");
if (use_sideband == 1) strbuf_addstr(&c, " side-band");
- if (args.use_thin_pack) strbuf_addstr(&c, " thin-pack");
- if (args.no_progress) strbuf_addstr(&c, " no-progress");
- if (args.include_tag) strbuf_addstr(&c, " include-tag");
+ if (args->use_thin_pack) strbuf_addstr(&c, " thin-pack");
+ if (args->no_progress) strbuf_addstr(&c, " no-progress");
+ if (args->include_tag) strbuf_addstr(&c, " include-tag");
if (prefer_ofs_delta) strbuf_addstr(&c, " ofs-delta");
if (agent_supported) strbuf_addf(&c, " agent=%s",
git_user_agent_sanitized());
if (is_repository_shallow())
write_shallow_commits(&req_buf, 1);
- if (args.depth > 0)
- packet_buf_write(&req_buf, "deepen %d", args.depth);
+ if (args->depth > 0)
+ packet_buf_write(&req_buf, "deepen %d", args->depth);
packet_buf_flush(&req_buf);
state_len = req_buf.len;
- if (args.depth > 0) {
+ if (args->depth > 0) {
char line[1024];
unsigned char sha1[20];
- send_request(fd[1], &req_buf);
+ send_request(args, fd[1], &req_buf);
while (packet_read_line(fd[0], line, sizeof(line))) {
if (!prefixcmp(line, "shallow ")) {
if (get_sha1_hex(line + 8, sha1))
}
die("expected shallow/unshallow, got %s", line);
}
- } else if (!args.stateless_rpc)
- send_request(fd[1], &req_buf);
+ } else if (!args->stateless_rpc)
+ send_request(args, fd[1], &req_buf);
- if (!args.stateless_rpc) {
+ if (!args->stateless_rpc) {
/* If we aren't using the stateless-rpc interface
* we don't need to retain the headers.
*/
retval = -1;
while ((sha1 = get_rev())) {
packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
in_vain++;
if (flush_at <= ++count) {
int ack;
packet_buf_flush(&req_buf);
- send_request(fd[1], &req_buf);
+ send_request(args, fd[1], &req_buf);
strbuf_setlen(&req_buf, state_len);
flushes++;
- flush_at = next_flush(count);
+ flush_at = next_flush(args, count);
/*
* We keep one window "ahead" of the other side, and
* will wait for an ACK only on the next one
*/
- if (!args.stateless_rpc && count == INITIAL_FLUSH)
+ if (!args->stateless_rpc && count == INITIAL_FLUSH)
continue;
- consume_shallow_list(fd[0]);
+ consume_shallow_list(args, fd[0]);
do {
ack = get_ack(fd[0], result_sha1);
- if (args.verbose && ack)
+ if (args->verbose && ack)
fprintf(stderr, "got ack %d %s\n", ack,
sha1_to_hex(result_sha1));
switch (ack) {
lookup_commit(result_sha1);
if (!commit)
die("invalid commit %s", sha1_to_hex(result_sha1));
- if (args.stateless_rpc
+ if (args->stateless_rpc
&& ack == ACK_common
&& !(commit->object.flags & COMMON)) {
/* We need to replay the have for this object
} while (ack);
flushes--;
if (got_continue && MAX_IN_VAIN < in_vain) {
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "giving up\n");
break; /* give up */
}
done:
if (!got_ready || !no_done) {
packet_buf_write(&req_buf, "done\n");
- send_request(fd[1], &req_buf);
+ send_request(args, fd[1], &req_buf);
}
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "done\n");
if (retval != 0) {
multi_ack = 0;
}
strbuf_release(&req_buf);
- consume_shallow_list(fd[0]);
+ consume_shallow_list(args, fd[0]);
while (flushes || multi_ack) {
int ack = get_ack(fd[0], result_sha1);
if (ack) {
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "got ack (%d) %s\n", ack,
sha1_to_hex(result_sha1));
if (ack == ACK)
return 0;
}
-static void mark_recent_complete_commits(unsigned long cutoff)
+static void mark_recent_complete_commits(struct fetch_pack_args *args,
+ unsigned long cutoff)
{
while (complete && cutoff <= complete->item->date) {
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "Marking %s as complete\n",
sha1_to_hex(complete->item->object.sha1));
pop_most_recent_commit(&complete, COMPLETE);
return 1;
}
-static void filter_refs(struct ref **refs, struct string_list *sought)
+static void filter_refs(struct fetch_pack_args *args,
+ struct ref **refs, struct string_list *sought)
{
struct ref *newlist = NULL;
struct ref **newtail = &newlist;
}
}
- if (! keep && args.fetch_all &&
- (!args.depth || prefixcmp(ref->name, "refs/tags/")))
+ if (! keep && args->fetch_all &&
+ (!args->depth || prefixcmp(ref->name, "refs/tags/")))
keep = 1;
if (keep) {
mark_complete(NULL, ref->old_sha1, 0, NULL);
}
-static int everything_local(struct ref **refs, struct string_list *sought)
+static int everything_local(struct fetch_pack_args *args,
+ struct ref **refs, struct string_list *sought)
{
struct ref *ref;
int retval;
}
}
- if (!args.depth) {
+ if (!args->depth) {
for_each_ref(mark_complete, NULL);
for_each_alternate_ref(mark_alternate_complete, NULL);
if (cutoff)
- mark_recent_complete_commits(cutoff);
+ mark_recent_complete_commits(args, cutoff);
}
/*
}
}
- filter_refs(refs, sought);
+ filter_refs(args, refs, sought);
for (retval = 1, ref = *refs; ref ; ref = ref->next) {
const unsigned char *remote = ref->old_sha1;
o = lookup_object(remote);
if (!o || !(o->flags & COMPLETE)) {
retval = 0;
- if (!args.verbose)
+ if (!args->verbose)
continue;
fprintf(stderr,
"want %s (%s)\n", sha1_to_hex(remote),
}
hashcpy(ref->new_sha1, local);
- if (!args.verbose)
+ if (!args->verbose)
continue;
fprintf(stderr,
"already have %s (%s)\n", sha1_to_hex(remote),
return ret;
}
-static int get_pack(int xd[2], char **pack_lockfile)
+static int get_pack(struct fetch_pack_args *args,
+ int xd[2], char **pack_lockfile)
{
struct async demux;
const char *argv[20];
char keep_arg[256];
char hdr_arg[256];
const char **av;
- int do_keep = args.keep_pack;
+ int do_keep = args->keep_pack;
struct child_process cmd;
memset(&demux, 0, sizeof(demux));
cmd.argv = argv;
av = argv;
*hdr_arg = 0;
- if (!args.keep_pack && unpack_limit) {
+ if (!args->keep_pack && unpack_limit) {
struct pack_header header;
if (read_pack_header(demux.out, &header))
cmd.out = -1;
*av++ = "index-pack";
*av++ = "--stdin";
- if (!args.quiet && !args.no_progress)
+ if (!args->quiet && !args->no_progress)
*av++ = "-v";
- if (args.use_thin_pack)
+ if (args->use_thin_pack)
*av++ = "--fix-thin";
- if (args.lock_pack || unpack_limit) {
+ if (args->lock_pack || unpack_limit) {
int s = sprintf(keep_arg,
"--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
}
else {
*av++ = "unpack-objects";
- if (args.quiet || args.no_progress)
+ if (args->quiet || args->no_progress)
*av++ = "-q";
}
if (*hdr_arg)
return 0;
}
-static struct ref *do_fetch_pack(int fd[2],
- const struct ref *orig_ref,
- struct string_list *sought,
- char **pack_lockfile)
+static struct ref *do_fetch_pack(struct fetch_pack_args *args,
+ int fd[2],
+ const struct ref *orig_ref,
+ struct string_list *sought,
+ char **pack_lockfile)
{
struct ref *ref = copy_ref_list(orig_ref);
unsigned char sha1[20];
if (is_repository_shallow() && !server_supports("shallow"))
die("Server does not support shallow clients");
if (server_supports("multi_ack_detailed")) {
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "Server supports multi_ack_detailed\n");
multi_ack = 2;
if (server_supports("no-done")) {
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "Server supports no-done\n");
- if (args.stateless_rpc)
+ if (args->stateless_rpc)
no_done = 1;
}
}
else if (server_supports("multi_ack")) {
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "Server supports multi_ack\n");
multi_ack = 1;
}
if (server_supports("side-band-64k")) {
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "Server supports side-band-64k\n");
use_sideband = 2;
}
else if (server_supports("side-band")) {
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "Server supports side-band\n");
use_sideband = 1;
}
if (!server_supports("thin-pack"))
- args.use_thin_pack = 0;
+ args->use_thin_pack = 0;
if (!server_supports("no-progress"))
- args.no_progress = 0;
+ args->no_progress = 0;
if (!server_supports("include-tag"))
- args.include_tag = 0;
+ args->include_tag = 0;
if (server_supports("ofs-delta")) {
- if (args.verbose)
+ if (args->verbose)
fprintf(stderr, "Server supports ofs-delta\n");
} else
prefer_ofs_delta = 0;
if ((agent_feature = server_feature_value("agent", &agent_len))) {
agent_supported = 1;
- if (args.verbose && agent_len)
+ if (args->verbose && agent_len)
fprintf(stderr, "Server version is %.*s\n",
agent_len, agent_feature);
}
- if (everything_local(&ref, sought)) {
+ if (everything_local(args, &ref, sought)) {
packet_flush(fd[1]);
goto all_done;
}
- if (find_common(fd, sha1, ref) < 0)
- if (!args.keep_pack)
+ if (find_common(args, fd, sha1, ref) < 0)
+ if (!args->keep_pack)
/* When cloning, it is not unusual to have
* no common commit.
*/
warning("no common commits");
- if (args.stateless_rpc)
+ if (args->stateless_rpc)
packet_flush(fd[1]);
- if (get_pack(fd, pack_lockfile))
+ if (get_pack(args, fd, pack_lockfile))
die("git fetch-pack: fetch failed.");
all_done:
char *pack_lockfile = NULL;
char **pack_lockfile_ptr = NULL;
struct child_process *conn;
+ struct fetch_pack_args args;
packet_trace_identity("fetch-pack");
+ memset(&args, 0, sizeof(args));
+ args.uploadpack = "git-upload-pack";
+
for (i = 1; i < argc && *argv[i] == '-'; i++) {
const char *arg = argv[i];
return ret;
}
-struct ref *fetch_pack(struct fetch_pack_args *my_args,
+struct ref *fetch_pack(struct fetch_pack_args *args,
int fd[], struct child_process *conn,
const struct ref *ref,
const char *dest,
struct ref *ref_cpy;
fetch_pack_setup();
- if (&args != my_args)
- memcpy(&args, my_args, sizeof(args));
- if (args.depth > 0) {
+ if (args->depth > 0) {
if (stat(git_path("shallow"), &st))
st.st_mtime = 0;
}
packet_flush(fd[1]);
die("no matching remote head");
}
- ref_cpy = do_fetch_pack(fd, ref, sought, pack_lockfile);
+ ref_cpy = do_fetch_pack(args, fd, ref, sought, pack_lockfile);
- if (args.depth > 0) {
+ if (args->depth > 0) {
struct cache_time mtime;
struct strbuf sb = STRBUF_INIT;
char *shallow = git_path("shallow");