2005-07-04 20:26:53 +00:00
|
|
|
#include "cache.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2005-07-04 20:26:53 +00:00
|
|
|
#include "refs.h"
|
|
|
|
#include "pkt-line.h"
|
2006-09-10 10:20:24 +00:00
|
|
|
#include "sideband.h"
|
2018-06-29 01:21:51 +00:00
|
|
|
#include "repository.h"
|
2018-05-15 23:42:15 +00:00
|
|
|
#include "object-store.h"
|
2005-10-14 01:57:40 +00:00
|
|
|
#include "tag.h"
|
|
|
|
#include "object.h"
|
2005-10-28 02:48:32 +00:00
|
|
|
#include "commit.h"
|
2006-10-30 19:08:43 +00:00
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "list-objects.h"
|
2017-12-08 15:58:39 +00:00
|
|
|
#include "list-objects-filter.h"
|
|
|
|
#include "list-objects-filter-options.h"
|
2007-10-19 19:47:59 +00:00
|
|
|
#include "run-command.h"
|
2013-07-08 20:56:53 +00:00
|
|
|
#include "connect.h"
|
2011-08-05 20:54:06 +00:00
|
|
|
#include "sigchain.h"
|
2012-08-03 16:19:16 +00:00
|
|
|
#include "version.h"
|
upload/receive-pack: allow hiding ref hierarchies
A repository may have refs that are only used for its internal
bookkeeping purposes that should not be exposed to the others that
come over the network.
Teach upload-pack to omit some refs from its initial advertisement
by paying attention to the uploadpack.hiderefs multi-valued
configuration variable. Do the same to receive-pack via the
receive.hiderefs variable. As a convenient short-hand, allow using
transfer.hiderefs to set the value to both of these variables.
Any ref that is under the hierarchies listed on the value of these
variable is excluded from responses to requests made by "ls-remote",
"fetch", etc. (for upload-pack) and "push" (for receive-pack).
Because these hidden refs do not count as OUR_REF, an attempt to
fetch objects at the tip of them will be rejected, and because these
refs do not get advertised, "git push :" will not see local branches
that have the same name as them as "matching" ones to be sent.
An attempt to update/delete these hidden refs with an explicit
refspec, e.g. "git push origin :refs/hidden/22", is rejected. This
is not a new restriction. To the pusher, it would appear that there
is no such ref, so its push request will conclude with "Now that I
sent you all the data, it is time for you to update the refs. I saw
that the ref did not exist when I started pushing, and I want the
result to point at this commit". The receiving end will apply the
compare-and-swap rule to this request and rejects the push with
"Well, your update request conflicts with somebody else; I see there
is such a ref.", which is the right thing to do. Otherwise a push to
a hidden ref will always be "the last one wins", which is not a good
default.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-19 00:08:30 +00:00
|
|
|
#include "string-list.h"
|
2016-06-12 10:53:58 +00:00
|
|
|
#include "argv-array.h"
|
2016-10-11 21:20:16 +00:00
|
|
|
#include "prio-queue.h"
|
2017-10-16 17:55:26 +00:00
|
|
|
#include "protocol.h"
|
2017-12-08 15:58:39 +00:00
|
|
|
#include "quote.h"
|
2018-03-14 18:31:41 +00:00
|
|
|
#include "upload-pack.h"
|
2018-03-15 17:31:27 +00:00
|
|
|
#include "serve.h"
|
2018-08-20 18:24:34 +00:00
|
|
|
#include "commit-graph.h"
|
2018-07-20 16:33:13 +00:00
|
|
|
#include "commit-reach.h"
|
2005-07-04 20:26:53 +00:00
|
|
|
|
2014-03-25 13:23:26 +00:00
|
|
|
/* Remember to update object flag allocation in object.h */
|
2006-07-06 04:28:20 +00:00
|
|
|
#define THEY_HAVE (1u << 11)
|
|
|
|
#define OUR_REF (1u << 12)
|
|
|
|
#define WANTED (1u << 13)
|
|
|
|
#define COMMON_KNOWN (1u << 14)
|
|
|
|
|
2006-10-30 19:09:53 +00:00
|
|
|
#define SHALLOW (1u << 16)
|
|
|
|
#define NOT_SHALLOW (1u << 17)
|
|
|
|
#define CLIENT_SHALLOW (1u << 18)
|
2013-01-29 05:49:57 +00:00
|
|
|
#define HIDDEN_REF (1u << 19)
|
2006-10-30 19:09:53 +00:00
|
|
|
|
upload-pack: clear flags before each v2 request
Suppose a server has the following commit graph:
A B
\ /
O
We create a client by cloning A from the server with depth 1, and add
many commits to it (so that future fetches span multiple requests due to
lengthy negotiation). If it then fetches B using protocol v2, the fetch
spanning multiple requests, the resulting packfile does not contain O
even though the client did report that A is shallow.
This is because upload_pack_v2() can be called multiple times while
processing the same session. During the 2nd and all subsequent
invocations, some object flags remain from the previous invocations. In
particular, CLIENT_SHALLOW remains, preventing process_shallow() from
adding client-reported shallows to the "shallows" array, and hence
pack-objects not knowing about these client-reported shallows.
Therefore, teach upload_pack_v2() to clear object flags at the start of
each invocation. This has some other results:
- THEY_HAVE gates addition of objects to have_obj in process_haves().
Previously in upload_pack_v2(), have_obj needed to be static because
once an object is added to have_obj, it is never readded and thus we
needed to retain the contents of have_obj between invocations. Now
that flags are cleared, this is no longer necessary. This patch does
not change the behavior of ok_to_give_up() (THEY_HAVE is still set on
each "have") and got_oid() (used only in non-v2)); THEY_HAVE is not
used in any other function.
- WANTED gates addition of objects to want_obj in parse_want() and
parse_want_ref(). It is also used in receive_needs(), but that is
only used in non-v2. For the same reasons as THEY_HAVE, want_obj no
longer needs to be static in upload_pack_v2().
- CLIENT_SHALLOW is changed as discussed above.
Clearing of the other 5 flags does not affect functionality in v2. (Note
that in non-v2, upload_pack() is only called once per process, so each
invocation starts with blank flags anyway.)
- OUR_REF is only used in non-v2.
- COMMON_KNOWN is only used as a scratch flag in ok_to_give_up().
- SHALLOW is passed to invocations in deepen() and
deepen_by_rev_list(), but upload-pack doesn't use it.
- NOT_SHALLOW is used by send_shallow() and send_unshallow(), but
invocations of those functions are always preceded by code that sets
NOT_SHALLOW on the appropriate objects.
- HIDDEN_REF is only used in non-v2.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-18 20:43:29 +00:00
|
|
|
#define ALL_FLAGS (THEY_HAVE | OUR_REF | WANTED | COMMON_KNOWN | SHALLOW | \
|
|
|
|
NOT_SHALLOW | CLIENT_SHALLOW | HIDDEN_REF)
|
|
|
|
|
2017-04-26 19:29:31 +00:00
|
|
|
static timestamp_t oldest_have;
|
2006-07-06 04:28:20 +00:00
|
|
|
|
2013-01-29 04:45:43 +00:00
|
|
|
static int multi_ack;
|
2011-03-29 19:29:10 +00:00
|
|
|
static int no_done;
|
2008-03-04 03:27:33 +00:00
|
|
|
static int use_thin_pack, use_ofs_delta, use_include_tag;
|
2009-06-16 18:41:16 +00:00
|
|
|
static int no_progress, daemon_mode;
|
2015-05-21 20:23:38 +00:00
|
|
|
/* Allow specifying sha1 if it is a ref tip. */
|
|
|
|
#define ALLOW_TIP_SHA1 01
|
2015-05-21 20:23:39 +00:00
|
|
|
/* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
|
|
|
|
#define ALLOW_REACHABLE_SHA1 02
|
2016-11-11 17:23:48 +00:00
|
|
|
/* Allow request of any sha1. Implies ALLOW_TIP_SHA1 and ALLOW_REACHABLE_SHA1. */
|
|
|
|
#define ALLOW_ANY_SHA1 07
|
2015-05-21 20:23:38 +00:00
|
|
|
static unsigned int allow_unadvertised_object_request;
|
2009-06-09 23:50:18 +00:00
|
|
|
static int shallow_nr;
|
2009-09-03 23:08:33 +00:00
|
|
|
static struct object_array extra_edge_obj;
|
2006-08-15 17:23:48 +00:00
|
|
|
static unsigned int timeout;
|
2013-09-08 09:02:06 +00:00
|
|
|
static int keepalive = 5;
|
2006-09-10 23:27:08 +00:00
|
|
|
/* 0 for no sideband,
|
|
|
|
* otherwise maximum packet size (up to 65520 bytes).
|
|
|
|
*/
|
2006-08-15 17:23:48 +00:00
|
|
|
static int use_sideband;
|
2009-10-31 00:47:33 +00:00
|
|
|
static int stateless_rpc;
|
upload-pack: provide a hook for running pack-objects
When upload-pack serves a client request, it turns to
pack-objects to do the heavy lifting of creating a
packfile. There's no easy way to intercept the call to
pack-objects, but there are a few good reasons to want to do
so:
1. If you're debugging a client or server issue with
fetching, you may want to store a copy of the generated
packfile.
2. If you're gathering data from real-world fetches for
performance analysis or debugging, storing a copy of
the arguments and stdin lets you replay the pack
generation at your leisure.
3. You may want to insert a caching layer around
pack-objects; it is the most CPU- and memory-intensive
part of serving a fetch, and its output is a pure
function[1] of its input, making it an ideal place to
consolidate identical requests.
This patch adds a simple "hook" interface to intercept calls
to pack-objects. The new test demonstrates how it can be
used for debugging (using it for caching is a
straightforward extension; the tricky part is writing the
actual caching layer).
This hook is unlike the normal hook scripts found in the
"hooks/" directory of a repository. Because we promise that
upload-pack is safe to run in an untrusted repository, we
cannot execute arbitrary code or commands found in the
repository (neither in hooks/, nor in the config). So
instead, this hook is triggered from a config variable that
is explicitly ignored in the per-repo config.
The config variable holds the actual shell command to run as
the hook. Another approach would be to simply treat it as a
boolean: "should I respect the upload-pack hooks in this
repo?", and then run the script from "hooks/" as we usually
do. However, that isn't as flexible; there's no way to run a
hook approved by the site administrator (e.g., in
"/etc/gitconfig") on a repository whose contents are not
trusted. The approach taken by this patch is more
fine-grained, if a little less conventional for git hooks
(it does behave similar to other configured commands like
diff.external, etc).
[1] Pack-objects isn't _actually_ a pure function. Its
output depends on the exact packing of the object
database, and if multi-threading is used for delta
compression, can even differ racily. But for the
purposes of caching, that's OK; of the many possible
outputs for a given input, it is sufficient only that we
output one of them.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-05-18 22:45:37 +00:00
|
|
|
static const char *pack_objects_hook;
|
2005-10-19 21:27:01 +00:00
|
|
|
|
2017-12-08 15:58:39 +00:00
|
|
|
static int filter_capability_requested;
|
2018-03-28 20:33:03 +00:00
|
|
|
static int allow_filter;
|
2018-06-27 22:30:17 +00:00
|
|
|
static int allow_ref_in_want;
|
2017-12-08 15:58:39 +00:00
|
|
|
static struct list_objects_filter_options filter_options;
|
|
|
|
|
2019-01-16 19:28:14 +00:00
|
|
|
static int allow_sideband_all;
|
|
|
|
|
2005-10-19 21:27:01 +00:00
|
|
|
static void reset_timeout(void)
|
|
|
|
{
|
|
|
|
alarm(timeout);
|
|
|
|
}
|
2005-07-04 22:29:17 +00:00
|
|
|
|
2016-06-14 14:49:17 +00:00
|
|
|
static void send_client_data(int fd, const char *data, ssize_t sz)
|
2006-06-21 07:30:21 +00:00
|
|
|
{
|
2016-06-14 14:49:16 +00:00
|
|
|
if (use_sideband) {
|
|
|
|
send_sideband(1, fd, data, sz, use_sideband);
|
2016-06-14 14:49:17 +00:00
|
|
|
return;
|
2016-06-14 14:49:16 +00:00
|
|
|
}
|
2006-09-10 10:20:24 +00:00
|
|
|
if (fd == 3)
|
|
|
|
/* emergency quit */
|
|
|
|
fd = 2;
|
|
|
|
if (fd == 2) {
|
2007-01-08 15:58:23 +00:00
|
|
|
/* XXX: are we happy to lose stuff here? */
|
2006-09-10 10:20:24 +00:00
|
|
|
xwrite(fd, data, sz);
|
2016-06-14 14:49:17 +00:00
|
|
|
return;
|
2006-06-21 07:30:21 +00:00
|
|
|
}
|
2013-02-20 20:01:56 +00:00
|
|
|
write_or_die(fd, data, sz);
|
2006-06-21 07:30:21 +00:00
|
|
|
}
|
|
|
|
|
2014-03-11 12:59:46 +00:00
|
|
|
static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
|
|
|
|
{
|
|
|
|
FILE *fp = cb_data;
|
|
|
|
if (graft->nr_parent == -1)
|
2015-03-13 23:39:34 +00:00
|
|
|
fprintf(fp, "--shallow %s\n", oid_to_hex(&graft->oid));
|
2014-03-11 12:59:46 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-10-18 20:43:28 +00:00
|
|
|
static void create_pack_file(const struct object_array *have_obj,
|
|
|
|
const struct object_array *want_obj)
|
2005-07-04 22:29:17 +00:00
|
|
|
{
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process pack_objects = CHILD_PROCESS_INIT;
|
2006-06-21 05:48:23 +00:00
|
|
|
char data[8193], progress[128];
|
2006-06-21 07:30:21 +00:00
|
|
|
char abort_msg[] = "aborting due to possible repository "
|
|
|
|
"corruption on the remote side.";
|
2006-06-21 01:26:34 +00:00
|
|
|
int buffered = -1;
|
2009-12-10 20:17:11 +00:00
|
|
|
ssize_t sz;
|
2016-02-25 12:13:26 +00:00
|
|
|
int i;
|
2013-08-16 09:52:05 +00:00
|
|
|
FILE *pipe_fd;
|
2005-07-04 23:35:13 +00:00
|
|
|
|
upload-pack: provide a hook for running pack-objects
When upload-pack serves a client request, it turns to
pack-objects to do the heavy lifting of creating a
packfile. There's no easy way to intercept the call to
pack-objects, but there are a few good reasons to want to do
so:
1. If you're debugging a client or server issue with
fetching, you may want to store a copy of the generated
packfile.
2. If you're gathering data from real-world fetches for
performance analysis or debugging, storing a copy of
the arguments and stdin lets you replay the pack
generation at your leisure.
3. You may want to insert a caching layer around
pack-objects; it is the most CPU- and memory-intensive
part of serving a fetch, and its output is a pure
function[1] of its input, making it an ideal place to
consolidate identical requests.
This patch adds a simple "hook" interface to intercept calls
to pack-objects. The new test demonstrates how it can be
used for debugging (using it for caching is a
straightforward extension; the tricky part is writing the
actual caching layer).
This hook is unlike the normal hook scripts found in the
"hooks/" directory of a repository. Because we promise that
upload-pack is safe to run in an untrusted repository, we
cannot execute arbitrary code or commands found in the
repository (neither in hooks/, nor in the config). So
instead, this hook is triggered from a config variable that
is explicitly ignored in the per-repo config.
The config variable holds the actual shell command to run as
the hook. Another approach would be to simply treat it as a
boolean: "should I respect the upload-pack hooks in this
repo?", and then run the script from "hooks/" as we usually
do. However, that isn't as flexible; there's no way to run a
hook approved by the site administrator (e.g., in
"/etc/gitconfig") on a repository whose contents are not
trusted. The approach taken by this patch is more
fine-grained, if a little less conventional for git hooks
(it does behave similar to other configured commands like
diff.external, etc).
[1] Pack-objects isn't _actually_ a pure function. Its
output depends on the exact packing of the object
database, and if multi-threading is used for delta
compression, can even differ racily. But for the
purposes of caching, that's OK; of the many possible
outputs for a given input, it is sufficient only that we
output one of them.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-05-18 22:45:37 +00:00
|
|
|
if (!pack_objects_hook)
|
|
|
|
pack_objects.git_cmd = 1;
|
|
|
|
else {
|
|
|
|
argv_array_push(&pack_objects.args, pack_objects_hook);
|
|
|
|
argv_array_push(&pack_objects.args, "git");
|
|
|
|
pack_objects.use_shell = 1;
|
|
|
|
}
|
|
|
|
|
2013-08-16 09:52:05 +00:00
|
|
|
if (shallow_nr) {
|
2016-02-25 12:13:26 +00:00
|
|
|
argv_array_push(&pack_objects.args, "--shallow-file");
|
|
|
|
argv_array_push(&pack_objects.args, "");
|
2009-06-09 23:50:18 +00:00
|
|
|
}
|
2016-02-25 12:13:26 +00:00
|
|
|
argv_array_push(&pack_objects.args, "pack-objects");
|
|
|
|
argv_array_push(&pack_objects.args, "--revs");
|
2013-08-16 09:52:05 +00:00
|
|
|
if (use_thin_pack)
|
2016-02-25 12:13:26 +00:00
|
|
|
argv_array_push(&pack_objects.args, "--thin");
|
2005-07-04 23:35:13 +00:00
|
|
|
|
2016-02-25 12:13:26 +00:00
|
|
|
argv_array_push(&pack_objects.args, "--stdout");
|
2014-12-24 23:05:40 +00:00
|
|
|
if (shallow_nr)
|
2016-02-25 12:13:26 +00:00
|
|
|
argv_array_push(&pack_objects.args, "--shallow");
|
2007-10-19 19:47:59 +00:00
|
|
|
if (!no_progress)
|
2016-02-25 12:13:26 +00:00
|
|
|
argv_array_push(&pack_objects.args, "--progress");
|
2007-10-19 19:47:59 +00:00
|
|
|
if (use_ofs_delta)
|
2016-02-25 12:13:26 +00:00
|
|
|
argv_array_push(&pack_objects.args, "--delta-base-offset");
|
2008-03-04 03:27:33 +00:00
|
|
|
if (use_include_tag)
|
2016-02-25 12:13:26 +00:00
|
|
|
argv_array_push(&pack_objects.args, "--include-tag");
|
2017-12-08 15:58:39 +00:00
|
|
|
if (filter_options.filter_spec) {
|
2019-01-08 00:17:09 +00:00
|
|
|
struct strbuf expanded_filter_spec = STRBUF_INIT;
|
|
|
|
expand_list_objects_filter_spec(&filter_options,
|
|
|
|
&expanded_filter_spec);
|
2017-12-08 15:58:42 +00:00
|
|
|
if (pack_objects.use_shell) {
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2019-01-08 00:17:09 +00:00
|
|
|
sq_quote_buf(&buf, expanded_filter_spec.buf);
|
2017-12-08 15:58:42 +00:00
|
|
|
argv_array_pushf(&pack_objects.args, "--filter=%s", buf.buf);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
} else {
|
|
|
|
argv_array_pushf(&pack_objects.args, "--filter=%s",
|
2019-01-08 00:17:09 +00:00
|
|
|
expanded_filter_spec.buf);
|
2017-12-08 15:58:42 +00:00
|
|
|
}
|
2017-12-08 15:58:39 +00:00
|
|
|
}
|
2007-10-19 19:47:59 +00:00
|
|
|
|
upload-pack: start pack-objects before async rev-list
In a pthread-enabled version of upload-pack, there's a race condition
that can cause a deadlock on the fflush(NULL) we call from run-command.
What happens is this:
1. Upload-pack is informed we are doing a shallow clone.
2. We call start_async() to spawn a thread that will generate rev-list
results to feed to pack-objects. It gets a file descriptor to a
pipe which will eventually hook to pack-objects.
3. The rev-list thread uses fdopen to create a new output stream
around the fd we gave it, called pack_pipe.
4. The thread writes results to pack_pipe. Outside of our control,
libc is doing locking on the stream. We keep writing until the OS
pipe buffer is full, and then we block in write(), still holding
the lock.
5. The main thread now uses start_command to spawn pack-objects.
Before forking, it calls fflush(NULL) to flush every stdio output
buffer. It blocks trying to get the lock on pack_pipe.
And we have a deadlock. The thread will block until somebody starts
reading from the pipe. But nobody will read from the pipe until we
finish flushing to the pipe.
To fix this, we swap the start order: we start the
pack-objects reader first, and then the rev-list writer
after. Thus the problematic fflush(NULL) happens before we
even open the new file descriptor (and even if it didn't,
flushing should no longer block, as the reader at the end of
the pipe is now active).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-04-06 21:33:33 +00:00
|
|
|
pack_objects.in = -1;
|
2007-10-19 19:47:59 +00:00
|
|
|
pack_objects.out = -1;
|
|
|
|
pack_objects.err = -1;
|
2007-10-19 19:48:03 +00:00
|
|
|
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
if (start_command(&pack_objects))
|
2008-08-31 16:39:19 +00:00
|
|
|
die("git upload-pack: unable to fork git-pack-objects");
|
2006-06-21 01:26:34 +00:00
|
|
|
|
2013-08-16 09:52:05 +00:00
|
|
|
pipe_fd = xfdopen(pack_objects.in, "w");
|
|
|
|
|
2014-03-11 12:59:46 +00:00
|
|
|
if (shallow_nr)
|
|
|
|
for_each_commit_graft(write_one_shallow, pipe_fd);
|
|
|
|
|
2018-10-18 20:43:28 +00:00
|
|
|
for (i = 0; i < want_obj->nr; i++)
|
2013-08-16 09:52:05 +00:00
|
|
|
fprintf(pipe_fd, "%s\n",
|
2018-10-18 20:43:28 +00:00
|
|
|
oid_to_hex(&want_obj->objects[i].item->oid));
|
2013-08-16 09:52:05 +00:00
|
|
|
fprintf(pipe_fd, "--not\n");
|
2018-10-18 20:43:27 +00:00
|
|
|
for (i = 0; i < have_obj->nr; i++)
|
2013-08-16 09:52:05 +00:00
|
|
|
fprintf(pipe_fd, "%s\n",
|
2018-10-18 20:43:27 +00:00
|
|
|
oid_to_hex(&have_obj->objects[i].item->oid));
|
2013-08-16 09:52:05 +00:00
|
|
|
for (i = 0; i < extra_edge_obj.nr; i++)
|
|
|
|
fprintf(pipe_fd, "%s\n",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&extra_edge_obj.objects[i].item->oid));
|
2013-08-16 09:52:05 +00:00
|
|
|
fprintf(pipe_fd, "\n");
|
|
|
|
fflush(pipe_fd);
|
|
|
|
fclose(pipe_fd);
|
2009-06-09 23:50:18 +00:00
|
|
|
|
2007-10-19 19:47:59 +00:00
|
|
|
/* We read from pack_objects.err to capture stderr output for
|
|
|
|
* progress bar, and pack_objects.out to capture the pack data.
|
2006-06-21 01:26:34 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
struct pollfd pfd[2];
|
2006-06-21 05:48:23 +00:00
|
|
|
int pe, pu, pollsize;
|
2013-09-08 09:01:31 +00:00
|
|
|
int ret;
|
2006-06-21 01:26:34 +00:00
|
|
|
|
2006-07-18 17:14:51 +00:00
|
|
|
reset_timeout();
|
|
|
|
|
2006-06-21 01:26:34 +00:00
|
|
|
pollsize = 0;
|
2006-06-21 05:48:23 +00:00
|
|
|
pe = pu = -1;
|
2006-06-21 01:26:34 +00:00
|
|
|
|
2007-10-19 19:47:59 +00:00
|
|
|
if (0 <= pack_objects.out) {
|
|
|
|
pfd[pollsize].fd = pack_objects.out;
|
2006-06-21 01:26:34 +00:00
|
|
|
pfd[pollsize].events = POLLIN;
|
|
|
|
pu = pollsize;
|
|
|
|
pollsize++;
|
|
|
|
}
|
2007-10-19 19:47:59 +00:00
|
|
|
if (0 <= pack_objects.err) {
|
|
|
|
pfd[pollsize].fd = pack_objects.err;
|
2006-06-21 05:48:23 +00:00
|
|
|
pfd[pollsize].events = POLLIN;
|
|
|
|
pe = pollsize;
|
|
|
|
pollsize++;
|
|
|
|
}
|
2006-06-21 01:26:34 +00:00
|
|
|
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
if (!pollsize)
|
|
|
|
break;
|
|
|
|
|
2014-08-22 15:19:11 +00:00
|
|
|
ret = poll(pfd, pollsize,
|
|
|
|
keepalive < 0 ? -1 : 1000 * keepalive);
|
|
|
|
|
2013-09-08 09:01:31 +00:00
|
|
|
if (ret < 0) {
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
if (errno != EINTR) {
|
2016-05-08 09:47:59 +00:00
|
|
|
error_errno("poll failed, resuming");
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
sleep(1);
|
2006-06-21 01:26:34 +00:00
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-11-11 22:24:42 +00:00
|
|
|
if (0 <= pe && (pfd[pe].revents & (POLLIN|POLLHUP))) {
|
|
|
|
/* Status ready; we ship that in the side-band
|
|
|
|
* or dump to the standard error.
|
|
|
|
*/
|
|
|
|
sz = xread(pack_objects.err, progress,
|
|
|
|
sizeof(progress));
|
|
|
|
if (0 < sz)
|
|
|
|
send_client_data(2, progress, sz);
|
|
|
|
else if (sz == 0) {
|
|
|
|
close(pack_objects.err);
|
|
|
|
pack_objects.err = -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
goto fail;
|
|
|
|
/* give priority to status messages */
|
|
|
|
continue;
|
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
if (0 <= pu && (pfd[pu].revents & (POLLIN|POLLHUP))) {
|
|
|
|
/* Data ready; we keep the last byte to ourselves
|
|
|
|
* in case we detect broken rev-list, so that we
|
|
|
|
* can leave the stream corrupted. This is
|
|
|
|
* unfortunate -- unpack-objects would happily
|
|
|
|
* accept a valid packdata with trailing garbage,
|
|
|
|
* so appending garbage after we pass all the
|
|
|
|
* pack data is not good enough to signal
|
|
|
|
* breakage to downstream.
|
|
|
|
*/
|
|
|
|
char *cp = data;
|
|
|
|
ssize_t outsz = 0;
|
|
|
|
if (0 <= buffered) {
|
|
|
|
*cp++ = buffered;
|
|
|
|
outsz++;
|
2006-06-21 01:26:34 +00:00
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
sz = xread(pack_objects.out, cp,
|
|
|
|
sizeof(data) - outsz);
|
|
|
|
if (0 < sz)
|
2009-12-10 20:17:11 +00:00
|
|
|
;
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
else if (sz == 0) {
|
|
|
|
close(pack_objects.out);
|
|
|
|
pack_objects.out = -1;
|
2006-06-21 05:48:23 +00:00
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
else
|
|
|
|
goto fail;
|
|
|
|
sz += outsz;
|
|
|
|
if (1 < sz) {
|
|
|
|
buffered = data[sz-1] & 0xFF;
|
|
|
|
sz--;
|
2006-06-21 01:26:34 +00:00
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
else
|
|
|
|
buffered = -1;
|
2016-06-14 14:49:17 +00:00
|
|
|
send_client_data(1, data, sz);
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
}
|
2013-09-08 09:01:31 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We hit the keepalive timeout without saying anything; send
|
|
|
|
* an empty message on the data sideband just to let the other
|
|
|
|
* side know we're still working on it, but don't have any data
|
|
|
|
* yet.
|
|
|
|
*
|
|
|
|
* If we don't have a sideband channel, there's no room in the
|
|
|
|
* protocol to say anything, so those clients are just out of
|
|
|
|
* luck.
|
|
|
|
*/
|
|
|
|
if (!ret && use_sideband) {
|
|
|
|
static const char buf[] = "0005\1";
|
|
|
|
write_or_die(1, buf, 5);
|
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
}
|
2006-06-21 01:26:34 +00:00
|
|
|
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
if (finish_command(&pack_objects)) {
|
2008-08-31 16:39:19 +00:00
|
|
|
error("git upload-pack: git-pack-objects died with error.");
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
2006-06-21 01:26:34 +00:00
|
|
|
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
/* flush the data */
|
|
|
|
if (0 <= buffered) {
|
|
|
|
data[0] = buffered;
|
2016-06-14 14:49:17 +00:00
|
|
|
send_client_data(1, data, 1);
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
fprintf(stderr, "flushed.\n");
|
2006-06-21 01:26:34 +00:00
|
|
|
}
|
upload-pack: Use finish_{command,async}() instead of waitpid().
upload-pack spawns two processes, rev-list and pack-objects, and carefully
monitors their status so that it can report failure to the remote end.
This change removes the complicated procedures on the grounds of the
following observations:
- If everything is OK, rev-list closes its output pipe end, upon which
pack-objects (which reads from the pipe) sees EOF and terminates itself,
closing its output (and error) pipes. upload-pack reads from both until
it sees EOF in both. It collects the exit codes of the child processes
(which indicate success) and terminates successfully.
- If rev-list sees an error, it closes its output and terminates with
failure. pack-objects sees EOF in its input and terminates successfully.
Again upload-pack reads its inputs until EOF. When it now collects
the exit codes of its child processes, it notices the failure of rev-list
and signals failure to the remote end.
- If pack-objects sees an error, it terminates with failure. Since this
breaks the pipe to rev-list, rev-list is killed with SIGPIPE.
upload-pack reads its input until EOF, then collects the exit codes of
the child processes, notices their failures, and signals failure to the
remote end.
- If upload-pack itself dies unexpectedly, pack-objects is killed with
SIGPIPE, and subsequently also rev-list.
The upshot of this is that precise monitoring of child processes is not
required because both terminate if either one of them dies unexpectedly.
This allows us to use finish_command() and finish_async() instead of
an explicit waitpid(2) call.
The change is smaller than it looks because most of it only reduces the
indentation of a large part of the inner loop.
Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-04 19:46:48 +00:00
|
|
|
if (use_sideband)
|
|
|
|
packet_flush(1);
|
|
|
|
return;
|
|
|
|
|
2006-06-21 01:26:34 +00:00
|
|
|
fail:
|
2006-06-21 07:30:21 +00:00
|
|
|
send_client_data(3, abort_msg, sizeof(abort_msg));
|
2008-08-31 16:39:19 +00:00
|
|
|
die("git upload-pack: %s", abort_msg);
|
2005-07-04 22:29:17 +00:00
|
|
|
}
|
|
|
|
|
2018-10-18 20:43:27 +00:00
|
|
|
static int got_oid(const char *hex, struct object_id *oid,
|
|
|
|
struct object_array *have_obj)
|
2005-07-04 20:26:53 +00:00
|
|
|
{
|
2006-07-06 01:00:02 +00:00
|
|
|
struct object *o;
|
2006-07-06 04:28:20 +00:00
|
|
|
int we_knew_they_have = 0;
|
2006-07-06 01:00:02 +00:00
|
|
|
|
2017-05-06 22:10:28 +00:00
|
|
|
if (get_oid_hex(hex, oid))
|
2008-08-31 16:39:19 +00:00
|
|
|
die("git upload-pack: expected SHA1 object, got '%s'", hex);
|
2017-05-06 22:10:28 +00:00
|
|
|
if (!has_object_file(oid))
|
2006-07-06 04:28:20 +00:00
|
|
|
return -1;
|
2006-07-06 01:00:02 +00:00
|
|
|
|
2018-06-29 01:21:51 +00:00
|
|
|
o = parse_object(the_repository, oid);
|
2006-07-06 01:00:02 +00:00
|
|
|
if (!o)
|
2017-05-06 22:10:28 +00:00
|
|
|
die("oops (%s)", oid_to_hex(oid));
|
2006-08-13 05:16:51 +00:00
|
|
|
if (o->type == OBJ_COMMIT) {
|
2006-07-06 01:00:02 +00:00
|
|
|
struct commit_list *parents;
|
2006-07-06 04:28:20 +00:00
|
|
|
struct commit *commit = (struct commit *)o;
|
2006-07-06 01:00:02 +00:00
|
|
|
if (o->flags & THEY_HAVE)
|
2006-07-06 04:28:20 +00:00
|
|
|
we_knew_they_have = 1;
|
|
|
|
else
|
|
|
|
o->flags |= THEY_HAVE;
|
|
|
|
if (!oldest_have || (commit->date < oldest_have))
|
|
|
|
oldest_have = commit->date;
|
|
|
|
for (parents = commit->parents;
|
2006-07-06 01:00:02 +00:00
|
|
|
parents;
|
|
|
|
parents = parents->next)
|
|
|
|
parents->item->object.flags |= THEY_HAVE;
|
2005-07-04 22:29:17 +00:00
|
|
|
}
|
2006-07-06 04:28:20 +00:00
|
|
|
if (!we_knew_they_have) {
|
2018-10-18 20:43:27 +00:00
|
|
|
add_object_array(o, NULL, have_obj);
|
2006-07-06 04:28:20 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-10-18 20:43:28 +00:00
|
|
|
static int ok_to_give_up(const struct object_array *have_obj,
|
|
|
|
struct object_array *want_obj)
|
2006-07-06 04:28:20 +00:00
|
|
|
{
|
2018-07-20 16:33:28 +00:00
|
|
|
uint32_t min_generation = GENERATION_NUMBER_ZERO;
|
2006-07-06 04:28:20 +00:00
|
|
|
|
2018-10-18 20:43:27 +00:00
|
|
|
if (!have_obj->nr)
|
2006-07-06 04:28:20 +00:00
|
|
|
return 0;
|
|
|
|
|
2018-10-18 20:43:28 +00:00
|
|
|
return can_all_from_reach_with_flag(want_obj, THEY_HAVE,
|
2018-07-20 16:33:28 +00:00
|
|
|
COMMON_KNOWN, oldest_have,
|
|
|
|
min_generation);
|
2005-07-04 20:26:53 +00:00
|
|
|
}
|
|
|
|
|
2018-12-29 21:19:14 +00:00
|
|
|
static int get_common_commits(struct packet_reader *reader,
|
|
|
|
struct object_array *have_obj,
|
2018-10-18 20:43:28 +00:00
|
|
|
struct object_array *want_obj)
|
2005-07-04 20:26:53 +00:00
|
|
|
{
|
2017-05-06 22:10:28 +00:00
|
|
|
struct object_id oid;
|
|
|
|
char last_hex[GIT_MAX_HEXSZ + 1];
|
2011-03-14 23:48:39 +00:00
|
|
|
int got_common = 0;
|
|
|
|
int got_other = 0;
|
2011-03-29 19:29:10 +00:00
|
|
|
int sent_ready = 0;
|
2005-07-04 20:26:53 +00:00
|
|
|
|
2005-10-28 02:48:32 +00:00
|
|
|
save_commit_buffer = 0;
|
|
|
|
|
2009-09-01 05:35:10 +00:00
|
|
|
for (;;) {
|
2016-06-12 10:53:49 +00:00
|
|
|
const char *arg;
|
|
|
|
|
2005-10-19 21:27:01 +00:00
|
|
|
reset_timeout();
|
2005-07-04 20:26:53 +00:00
|
|
|
|
2018-12-29 21:19:14 +00:00
|
|
|
if (packet_reader_read(reader) != PACKET_READ_NORMAL) {
|
2011-03-14 23:48:39 +00:00
|
|
|
if (multi_ack == 2 && got_common
|
2018-10-18 20:43:28 +00:00
|
|
|
&& !got_other && ok_to_give_up(have_obj, want_obj)) {
|
2011-03-29 19:29:10 +00:00
|
|
|
sent_ready = 1;
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "ACK %s ready\n", last_hex);
|
2011-03-29 19:29:10 +00:00
|
|
|
}
|
2018-10-18 20:43:27 +00:00
|
|
|
if (have_obj->nr == 0 || multi_ack)
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "NAK\n");
|
2011-03-29 19:29:10 +00:00
|
|
|
|
|
|
|
if (no_done && sent_ready) {
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "ACK %s\n", last_hex);
|
2011-03-29 19:29:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2009-10-31 00:47:33 +00:00
|
|
|
if (stateless_rpc)
|
|
|
|
exit(0);
|
2011-03-14 23:48:39 +00:00
|
|
|
got_common = 0;
|
|
|
|
got_other = 0;
|
2005-07-04 20:26:53 +00:00
|
|
|
continue;
|
|
|
|
}
|
2018-12-29 21:19:14 +00:00
|
|
|
if (skip_prefix(reader->line, "have ", &arg)) {
|
2018-10-18 20:43:27 +00:00
|
|
|
switch (got_oid(arg, &oid, have_obj)) {
|
2006-07-06 04:28:20 +00:00
|
|
|
case -1: /* they have what we do not */
|
2011-03-14 23:48:39 +00:00
|
|
|
got_other = 1;
|
2018-10-18 20:43:28 +00:00
|
|
|
if (multi_ack && ok_to_give_up(have_obj, want_obj)) {
|
2017-05-06 22:10:28 +00:00
|
|
|
const char *hex = oid_to_hex(&oid);
|
2011-03-29 19:29:10 +00:00
|
|
|
if (multi_ack == 2) {
|
|
|
|
sent_ready = 1;
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "ACK %s ready\n", hex);
|
2011-03-29 19:29:10 +00:00
|
|
|
} else
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "ACK %s continue\n", hex);
|
2009-10-31 00:47:25 +00:00
|
|
|
}
|
2006-07-06 04:28:20 +00:00
|
|
|
break;
|
|
|
|
default:
|
2011-03-14 23:48:39 +00:00
|
|
|
got_common = 1;
|
2018-05-02 00:25:51 +00:00
|
|
|
oid_to_hex_r(last_hex, &oid);
|
2009-10-31 00:47:25 +00:00
|
|
|
if (multi_ack == 2)
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "ACK %s common\n", last_hex);
|
2009-10-31 00:47:25 +00:00
|
|
|
else if (multi_ack)
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "ACK %s continue\n", last_hex);
|
2018-10-18 20:43:27 +00:00
|
|
|
else if (have_obj->nr == 1)
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "ACK %s\n", last_hex);
|
2006-07-06 04:28:20 +00:00
|
|
|
break;
|
2005-10-25 21:55:24 +00:00
|
|
|
}
|
2005-07-04 20:26:53 +00:00
|
|
|
continue;
|
|
|
|
}
|
2018-12-29 21:19:14 +00:00
|
|
|
if (!strcmp(reader->line, "done")) {
|
2018-10-18 20:43:27 +00:00
|
|
|
if (have_obj->nr > 0) {
|
2005-10-28 02:49:16 +00:00
|
|
|
if (multi_ack)
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "ACK %s\n", last_hex);
|
2005-10-28 02:49:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "NAK\n");
|
2005-07-04 20:26:53 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2018-12-29 21:19:14 +00:00
|
|
|
die("git upload-pack: expected SHA1 list, got '%s'", reader->line);
|
2005-07-04 20:26:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-29 05:49:57 +00:00
|
|
|
static int is_our_ref(struct object *o)
|
|
|
|
{
|
2015-05-21 20:23:39 +00:00
|
|
|
int allow_hidden_ref = (allow_unadvertised_object_request &
|
|
|
|
(ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1));
|
2015-05-21 20:23:38 +00:00
|
|
|
return o->flags & ((allow_hidden_ref ? HIDDEN_REF : 0) | OUR_REF);
|
2013-01-29 05:49:57 +00:00
|
|
|
}
|
|
|
|
|
2016-06-12 10:54:07 +00:00
|
|
|
/*
|
|
|
|
* on successful case, it's up to the caller to close cmd->out
|
|
|
|
*/
|
|
|
|
static int do_reachable_revlist(struct child_process *cmd,
|
2016-06-12 10:54:08 +00:00
|
|
|
struct object_array *src,
|
|
|
|
struct object_array *reachable)
|
2011-08-05 20:54:06 +00:00
|
|
|
{
|
|
|
|
static const char *argv[] = {
|
|
|
|
"rev-list", "--stdin", NULL,
|
|
|
|
};
|
|
|
|
struct object *o;
|
2018-05-02 00:25:51 +00:00
|
|
|
char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
|
2011-08-05 20:54:06 +00:00
|
|
|
int i;
|
2018-10-15 00:01:56 +00:00
|
|
|
const unsigned hexsz = the_hash_algo->hexsz;
|
2011-08-05 20:54:06 +00:00
|
|
|
|
2016-06-12 10:54:07 +00:00
|
|
|
cmd->argv = argv;
|
|
|
|
cmd->git_cmd = 1;
|
|
|
|
cmd->no_stderr = 1;
|
|
|
|
cmd->in = -1;
|
|
|
|
cmd->out = -1;
|
2011-08-05 20:54:06 +00:00
|
|
|
|
|
|
|
/*
|
2016-06-12 10:53:51 +00:00
|
|
|
* If the next rev-list --stdin encounters an unknown commit,
|
|
|
|
* it terminates, which will cause SIGPIPE in the write loop
|
2011-08-05 20:54:06 +00:00
|
|
|
* below.
|
|
|
|
*/
|
|
|
|
sigchain_push(SIGPIPE, SIG_IGN);
|
|
|
|
|
2016-06-12 10:54:07 +00:00
|
|
|
if (start_command(cmd))
|
2016-06-12 10:53:51 +00:00
|
|
|
goto error;
|
|
|
|
|
2011-08-05 20:54:06 +00:00
|
|
|
namebuf[0] = '^';
|
2018-10-15 00:01:56 +00:00
|
|
|
namebuf[hexsz + 1] = '\n';
|
2011-08-05 20:54:06 +00:00
|
|
|
for (i = get_max_object_index(); 0 < i; ) {
|
|
|
|
o = get_indexed_object(--i);
|
2011-08-24 05:47:17 +00:00
|
|
|
if (!o)
|
|
|
|
continue;
|
2016-06-12 10:54:08 +00:00
|
|
|
if (reachable && o->type == OBJ_COMMIT)
|
|
|
|
o->flags &= ~TMP_MARK;
|
2013-01-29 05:49:57 +00:00
|
|
|
if (!is_our_ref(o))
|
2011-08-05 20:54:06 +00:00
|
|
|
continue;
|
2018-10-15 00:01:56 +00:00
|
|
|
memcpy(namebuf + 1, oid_to_hex(&o->oid), hexsz);
|
|
|
|
if (write_in_full(cmd->in, namebuf, hexsz + 2) < 0)
|
2011-08-05 20:54:06 +00:00
|
|
|
goto error;
|
|
|
|
}
|
2018-10-15 00:01:56 +00:00
|
|
|
namebuf[hexsz] = '\n';
|
2016-06-12 10:53:52 +00:00
|
|
|
for (i = 0; i < src->nr; i++) {
|
|
|
|
o = src->objects[i].item;
|
2016-06-12 10:54:08 +00:00
|
|
|
if (is_our_ref(o)) {
|
|
|
|
if (reachable)
|
|
|
|
add_object_array(o, NULL, reachable);
|
2011-08-05 20:54:06 +00:00
|
|
|
continue;
|
2016-06-12 10:54:08 +00:00
|
|
|
}
|
|
|
|
if (reachable && o->type == OBJ_COMMIT)
|
|
|
|
o->flags |= TMP_MARK;
|
2018-10-15 00:01:56 +00:00
|
|
|
memcpy(namebuf, oid_to_hex(&o->oid), hexsz);
|
|
|
|
if (write_in_full(cmd->in, namebuf, hexsz + 1) < 0)
|
2011-08-05 20:54:06 +00:00
|
|
|
goto error;
|
|
|
|
}
|
2016-06-12 10:54:07 +00:00
|
|
|
close(cmd->in);
|
|
|
|
cmd->in = -1;
|
|
|
|
sigchain_pop(SIGPIPE);
|
2011-08-05 20:54:06 +00:00
|
|
|
|
2016-06-12 10:54:07 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
2011-08-05 20:54:06 +00:00
|
|
|
sigchain_pop(SIGPIPE);
|
|
|
|
|
2016-06-12 10:54:07 +00:00
|
|
|
if (cmd->in >= 0)
|
|
|
|
close(cmd->in);
|
|
|
|
if (cmd->out >= 0)
|
|
|
|
close(cmd->out);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-06-12 10:54:08 +00:00
|
|
|
static int get_reachable_list(struct object_array *src,
|
|
|
|
struct object_array *reachable)
|
|
|
|
{
|
|
|
|
struct child_process cmd = CHILD_PROCESS_INIT;
|
|
|
|
int i;
|
|
|
|
struct object *o;
|
2018-05-02 00:25:51 +00:00
|
|
|
char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
|
|
|
|
const unsigned hexsz = the_hash_algo->hexsz;
|
2016-06-12 10:54:08 +00:00
|
|
|
|
|
|
|
if (do_reachable_revlist(&cmd, src, reachable) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2018-05-02 00:25:51 +00:00
|
|
|
while ((i = read_in_full(cmd.out, namebuf, hexsz + 1)) == hexsz + 1) {
|
2016-06-12 10:54:08 +00:00
|
|
|
struct object_id sha1;
|
2018-05-02 00:25:51 +00:00
|
|
|
const char *p;
|
2016-06-12 10:54:08 +00:00
|
|
|
|
2018-05-02 00:25:51 +00:00
|
|
|
if (parse_oid_hex(namebuf, &sha1, &p) || *p != '\n')
|
2016-06-12 10:54:08 +00:00
|
|
|
break;
|
|
|
|
|
2018-06-29 01:21:52 +00:00
|
|
|
o = lookup_object(the_repository, sha1.hash);
|
2016-06-12 10:54:08 +00:00
|
|
|
if (o && o->type == OBJ_COMMIT) {
|
|
|
|
o->flags &= ~TMP_MARK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (i = get_max_object_index(); 0 < i; i--) {
|
|
|
|
o = get_indexed_object(i - 1);
|
|
|
|
if (o && o->type == OBJ_COMMIT &&
|
|
|
|
(o->flags & TMP_MARK)) {
|
|
|
|
add_object_array(o, NULL, reachable);
|
|
|
|
o->flags &= ~TMP_MARK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
close(cmd.out);
|
|
|
|
|
|
|
|
if (finish_command(&cmd))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-12 10:54:07 +00:00
|
|
|
static int has_unreachable(struct object_array *src)
|
|
|
|
{
|
|
|
|
struct child_process cmd = CHILD_PROCESS_INIT;
|
|
|
|
char buf[1];
|
|
|
|
int i;
|
|
|
|
|
2016-06-12 10:54:08 +00:00
|
|
|
if (do_reachable_revlist(&cmd, src, NULL) < 0)
|
2016-06-12 10:54:07 +00:00
|
|
|
return 1;
|
2011-08-05 20:54:06 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The commits out of the rev-list are not ancestors of
|
|
|
|
* our ref.
|
|
|
|
*/
|
2016-06-12 10:54:07 +00:00
|
|
|
i = read_in_full(cmd.out, buf, 1);
|
2011-08-05 20:54:06 +00:00
|
|
|
if (i)
|
|
|
|
goto error;
|
|
|
|
close(cmd.out);
|
2016-06-12 10:53:51 +00:00
|
|
|
cmd.out = -1;
|
2011-08-05 20:54:06 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* rev-list may have died by encountering a bad commit
|
|
|
|
* in the history, in which case we do want to bail out
|
|
|
|
* even when it showed no commit.
|
|
|
|
*/
|
|
|
|
if (finish_command(&cmd))
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* All the non-tip ones are ancestors of what we advertised */
|
2016-06-12 10:53:52 +00:00
|
|
|
return 0;
|
2011-08-05 20:54:06 +00:00
|
|
|
|
|
|
|
error:
|
2016-06-12 10:53:51 +00:00
|
|
|
sigchain_pop(SIGPIPE);
|
|
|
|
if (cmd.out >= 0)
|
|
|
|
close(cmd.out);
|
2016-06-12 10:53:52 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2016-06-12 10:53:51 +00:00
|
|
|
|
upload-pack: send ERR packet for non-tip objects
Commit bdb31eada7 (upload-pack: report "not our ref" to client,
2017-02-23) catches the case where a client asks for an object we don't
have, and issues a message that the client can show to the user (in
addition to dying and writing to stderr).
There's a similar case (with the same message) when the client asks for
an object which we _do_ have, but which isn't a ref tip (or isn't
reachable, when uploadpack.allowReachableSHA1InWant is true). Let's give
that one the same treatment, for the same reason (namely that it's more
informative to the client than just hanging up, since they won't see our
stderr over some protocols).
There are two tests here. We cover it most directly in t5530 by invoking
upload-pack, which matches the existing "not our ref" test.
But a more end-to-end check is that "git fetch" actually shows the
message to the client. We're already checking in t5516 that this case
fails, so we can just check stderr there, too. Note that even after we
started ignoring SIGPIPE in 8bf4becf0c, this could in theory still be
racy as described in that commit (because we die() on write failures
before pumping the connection for any ERR packets).
In practice this should be OK for this case. The server will not
actually check reachability until it has received our whole group of
"want" lines. And since we have no objects in the repository, we won't
send any "have" lines, meaning we're always waiting to read the server
response.
Note also that this case cannot happen in the v2 protocol, since it
allows any available object to be requested. However, we don't have to
take any steps to protect against the upcoming GIT_TEST_PROTOCOL_VERSION
in our tests:
- the tests in t5516 would already need to be skipped under v2, and
that is covered by ab0c5f5096 (tests: always test fetch of
unreachable with v0, 2019-02-25)
- the tests in t5530 invoke upload-pack directly, which will continue
to default to v0. Eventually we may have a test setting which uses
v2 even for bare upload-pack calls, but we can't override it here
until we know what the setting looks like.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-04-13 05:53:34 +00:00
|
|
|
static void check_non_tip(struct object_array *want_obj,
|
|
|
|
struct packet_writer *writer)
|
2016-06-12 10:53:52 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In the normal in-process case without
|
|
|
|
* uploadpack.allowReachableSHA1InWant,
|
|
|
|
* non-tip requests can never happen.
|
|
|
|
*/
|
|
|
|
if (!stateless_rpc && !(allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1))
|
|
|
|
goto error;
|
2018-10-18 20:43:28 +00:00
|
|
|
if (!has_unreachable(want_obj))
|
2016-06-12 10:53:52 +00:00
|
|
|
/* All the non-tip ones are ancestors of what we advertised */
|
|
|
|
return;
|
2011-08-05 20:54:06 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
/* Pick one of them (we know there at least is one) */
|
2018-10-18 20:43:28 +00:00
|
|
|
for (i = 0; i < want_obj->nr; i++) {
|
|
|
|
struct object *o = want_obj->objects[i].item;
|
upload-pack: send ERR packet for non-tip objects
Commit bdb31eada7 (upload-pack: report "not our ref" to client,
2017-02-23) catches the case where a client asks for an object we don't
have, and issues a message that the client can show to the user (in
addition to dying and writing to stderr).
There's a similar case (with the same message) when the client asks for
an object which we _do_ have, but which isn't a ref tip (or isn't
reachable, when uploadpack.allowReachableSHA1InWant is true). Let's give
that one the same treatment, for the same reason (namely that it's more
informative to the client than just hanging up, since they won't see our
stderr over some protocols).
There are two tests here. We cover it most directly in t5530 by invoking
upload-pack, which matches the existing "not our ref" test.
But a more end-to-end check is that "git fetch" actually shows the
message to the client. We're already checking in t5516 that this case
fails, so we can just check stderr there, too. Note that even after we
started ignoring SIGPIPE in 8bf4becf0c, this could in theory still be
racy as described in that commit (because we die() on write failures
before pumping the connection for any ERR packets).
In practice this should be OK for this case. The server will not
actually check reachability until it has received our whole group of
"want" lines. And since we have no objects in the repository, we won't
send any "have" lines, meaning we're always waiting to read the server
response.
Note also that this case cannot happen in the v2 protocol, since it
allows any available object to be requested. However, we don't have to
take any steps to protect against the upcoming GIT_TEST_PROTOCOL_VERSION
in our tests:
- the tests in t5516 would already need to be skipped under v2, and
that is covered by ab0c5f5096 (tests: always test fetch of
unreachable with v0, 2019-02-25)
- the tests in t5530 invoke upload-pack directly, which will continue
to default to v0. Eventually we may have a test setting which uses
v2 even for bare upload-pack calls, but we can't override it here
until we know what the setting looks like.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-04-13 05:53:34 +00:00
|
|
|
if (!is_our_ref(o)) {
|
|
|
|
packet_writer_error(writer,
|
|
|
|
"upload-pack: not our ref %s",
|
|
|
|
oid_to_hex(&o->oid));
|
2011-08-05 20:54:06 +00:00
|
|
|
die("git upload-pack: not our ref %s",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&o->oid));
|
upload-pack: send ERR packet for non-tip objects
Commit bdb31eada7 (upload-pack: report "not our ref" to client,
2017-02-23) catches the case where a client asks for an object we don't
have, and issues a message that the client can show to the user (in
addition to dying and writing to stderr).
There's a similar case (with the same message) when the client asks for
an object which we _do_ have, but which isn't a ref tip (or isn't
reachable, when uploadpack.allowReachableSHA1InWant is true). Let's give
that one the same treatment, for the same reason (namely that it's more
informative to the client than just hanging up, since they won't see our
stderr over some protocols).
There are two tests here. We cover it most directly in t5530 by invoking
upload-pack, which matches the existing "not our ref" test.
But a more end-to-end check is that "git fetch" actually shows the
message to the client. We're already checking in t5516 that this case
fails, so we can just check stderr there, too. Note that even after we
started ignoring SIGPIPE in 8bf4becf0c, this could in theory still be
racy as described in that commit (because we die() on write failures
before pumping the connection for any ERR packets).
In practice this should be OK for this case. The server will not
actually check reachability until it has received our whole group of
"want" lines. And since we have no objects in the repository, we won't
send any "have" lines, meaning we're always waiting to read the server
response.
Note also that this case cannot happen in the v2 protocol, since it
allows any available object to be requested. However, we don't have to
take any steps to protect against the upcoming GIT_TEST_PROTOCOL_VERSION
in our tests:
- the tests in t5516 would already need to be skipped under v2, and
that is covered by ab0c5f5096 (tests: always test fetch of
unreachable with v0, 2019-02-25)
- the tests in t5530 invoke upload-pack directly, which will continue
to default to v0. Eventually we may have a test setting which uses
v2 even for bare upload-pack calls, but we can't override it here
until we know what the setting looks like.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-04-13 05:53:34 +00:00
|
|
|
}
|
2011-08-05 20:54:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
static void send_shallow(struct packet_writer *writer,
|
|
|
|
struct commit_list *result)
|
2016-06-12 10:53:46 +00:00
|
|
|
{
|
|
|
|
while (result) {
|
|
|
|
struct object *object = &result->item->object;
|
|
|
|
if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_write(writer, "shallow %s",
|
|
|
|
oid_to_hex(&object->oid));
|
2018-05-17 22:51:44 +00:00
|
|
|
register_shallow(the_repository, &object->oid);
|
2016-06-12 10:53:46 +00:00
|
|
|
shallow_nr++;
|
|
|
|
}
|
|
|
|
result = result->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
static void send_unshallow(struct packet_writer *writer,
|
|
|
|
const struct object_array *shallows,
|
2018-10-18 20:43:28 +00:00
|
|
|
struct object_array *want_obj)
|
2016-06-12 10:53:45 +00:00
|
|
|
{
|
|
|
|
int i;
|
2016-06-12 10:53:48 +00:00
|
|
|
|
2016-06-12 10:53:45 +00:00
|
|
|
for (i = 0; i < shallows->nr; i++) {
|
|
|
|
struct object *object = shallows->objects[i].item;
|
|
|
|
if (object->flags & NOT_SHALLOW) {
|
|
|
|
struct commit_list *parents;
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_write(writer, "unshallow %s",
|
|
|
|
oid_to_hex(&object->oid));
|
2016-06-12 10:53:45 +00:00
|
|
|
object->flags &= ~CLIENT_SHALLOW;
|
2016-06-12 10:53:48 +00:00
|
|
|
/*
|
|
|
|
* We want to _register_ "object" as shallow, but we
|
|
|
|
* also need to traverse object's parents to deepen a
|
|
|
|
* shallow clone. Unregister it for now so we can
|
|
|
|
* parse and add the parents to the want list, then
|
|
|
|
* re-register it.
|
|
|
|
*/
|
2017-05-06 22:10:06 +00:00
|
|
|
unregister_shallow(&object->oid);
|
2016-06-12 10:53:45 +00:00
|
|
|
object->parsed = 0;
|
|
|
|
parse_commit_or_die((struct commit *)object);
|
|
|
|
parents = ((struct commit *)object)->parents;
|
|
|
|
while (parents) {
|
|
|
|
add_object_array(&parents->item->object,
|
2018-10-18 20:43:28 +00:00
|
|
|
NULL, want_obj);
|
2016-06-12 10:53:45 +00:00
|
|
|
parents = parents->next;
|
|
|
|
}
|
|
|
|
add_object_array(object, NULL, &extra_edge_obj);
|
|
|
|
}
|
|
|
|
/* make sure commit traversal conforms to client */
|
2018-05-17 22:51:44 +00:00
|
|
|
register_shallow(the_repository, &object->oid);
|
2016-06-12 10:53:45 +00:00
|
|
|
}
|
2016-06-12 10:53:48 +00:00
|
|
|
}
|
|
|
|
|
2018-12-18 21:24:35 +00:00
|
|
|
static int check_ref(const char *refname_full, const struct object_id *oid,
|
|
|
|
int flag, void *cb_data);
|
2019-01-15 19:40:27 +00:00
|
|
|
static void deepen(struct packet_writer *writer, int depth, int deepen_relative,
|
2018-10-18 20:43:28 +00:00
|
|
|
struct object_array *shallows, struct object_array *want_obj)
|
2016-06-12 10:53:48 +00:00
|
|
|
{
|
2018-05-17 22:51:46 +00:00
|
|
|
if (depth == INFINITE_DEPTH && !is_repository_shallow(the_repository)) {
|
2016-06-12 10:53:48 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < shallows->nr; i++) {
|
|
|
|
struct object *object = shallows->objects[i].item;
|
|
|
|
object->flags |= NOT_SHALLOW;
|
|
|
|
}
|
fetch, upload-pack: --deepen=N extends shallow boundary by N commits
In git-fetch, --depth argument is always relative with the latest
remote refs. This makes it a bit difficult to cover this use case,
where the user wants to make the shallow history, say 3 levels
deeper. It would work if remote refs have not moved yet, but nobody
can guarantee that, especially when that use case is performed a
couple months after the last clone or "git fetch --depth". Also,
modifying shallow boundary using --depth does not work well with
clones created by --since or --not.
This patch fixes that. A new argument --deepen=<N> will add <N> more (*)
parent commits to the current history regardless of where remote refs
are.
Have/Want negotiation is still respected. So if remote refs move, the
server will send two chunks: one between "have" and "want" and another
to extend shallow history. In theory, the client could send no "want"s
in order to get the second chunk only. But the protocol does not allow
that. Either you send no want lines, which means ls-remote; or you
have to send at least one want line that carries deep-relative to the
server..
The main work was done by Dongcan Jiang. I fixed it up here and there.
And of course all the bugs belong to me.
(*) We could even support --deepen=<N> where <N> is negative. In that
case we can cut some history from the shallow clone. This operation
(and --depth=<shorter depth>) does not require interaction with remote
side (and more complicated to implement as a result).
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Dongcan Jiang <dongcan.jiang@gmail.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-12 10:54:09 +00:00
|
|
|
} else if (deepen_relative) {
|
|
|
|
struct object_array reachable_shallows = OBJECT_ARRAY_INIT;
|
|
|
|
struct commit_list *result;
|
|
|
|
|
2018-12-18 21:24:35 +00:00
|
|
|
/*
|
|
|
|
* Checking for reachable shallows requires that our refs be
|
|
|
|
* marked with OUR_REF.
|
|
|
|
*/
|
|
|
|
head_ref_namespaced(check_ref, NULL);
|
|
|
|
for_each_namespaced_ref(check_ref, NULL);
|
|
|
|
|
fetch, upload-pack: --deepen=N extends shallow boundary by N commits
In git-fetch, --depth argument is always relative with the latest
remote refs. This makes it a bit difficult to cover this use case,
where the user wants to make the shallow history, say 3 levels
deeper. It would work if remote refs have not moved yet, but nobody
can guarantee that, especially when that use case is performed a
couple months after the last clone or "git fetch --depth". Also,
modifying shallow boundary using --depth does not work well with
clones created by --since or --not.
This patch fixes that. A new argument --deepen=<N> will add <N> more (*)
parent commits to the current history regardless of where remote refs
are.
Have/Want negotiation is still respected. So if remote refs move, the
server will send two chunks: one between "have" and "want" and another
to extend shallow history. In theory, the client could send no "want"s
in order to get the second chunk only. But the protocol does not allow
that. Either you send no want lines, which means ls-remote; or you
have to send at least one want line that carries deep-relative to the
server..
The main work was done by Dongcan Jiang. I fixed it up here and there.
And of course all the bugs belong to me.
(*) We could even support --deepen=<N> where <N> is negative. In that
case we can cut some history from the shallow clone. This operation
(and --depth=<shorter depth>) does not require interaction with remote
side (and more complicated to implement as a result).
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Dongcan Jiang <dongcan.jiang@gmail.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-12 10:54:09 +00:00
|
|
|
get_reachable_list(shallows, &reachable_shallows);
|
|
|
|
result = get_shallow_commits(&reachable_shallows,
|
|
|
|
depth + 1,
|
|
|
|
SHALLOW, NOT_SHALLOW);
|
2019-01-15 19:40:27 +00:00
|
|
|
send_shallow(writer, result);
|
fetch, upload-pack: --deepen=N extends shallow boundary by N commits
In git-fetch, --depth argument is always relative with the latest
remote refs. This makes it a bit difficult to cover this use case,
where the user wants to make the shallow history, say 3 levels
deeper. It would work if remote refs have not moved yet, but nobody
can guarantee that, especially when that use case is performed a
couple months after the last clone or "git fetch --depth". Also,
modifying shallow boundary using --depth does not work well with
clones created by --since or --not.
This patch fixes that. A new argument --deepen=<N> will add <N> more (*)
parent commits to the current history regardless of where remote refs
are.
Have/Want negotiation is still respected. So if remote refs move, the
server will send two chunks: one between "have" and "want" and another
to extend shallow history. In theory, the client could send no "want"s
in order to get the second chunk only. But the protocol does not allow
that. Either you send no want lines, which means ls-remote; or you
have to send at least one want line that carries deep-relative to the
server..
The main work was done by Dongcan Jiang. I fixed it up here and there.
And of course all the bugs belong to me.
(*) We could even support --deepen=<N> where <N> is negative. In that
case we can cut some history from the shallow clone. This operation
(and --depth=<shorter depth>) does not require interaction with remote
side (and more complicated to implement as a result).
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Dongcan Jiang <dongcan.jiang@gmail.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-12 10:54:09 +00:00
|
|
|
free_commit_list(result);
|
|
|
|
object_array_clear(&reachable_shallows);
|
2016-06-12 10:53:48 +00:00
|
|
|
} else {
|
|
|
|
struct commit_list *result;
|
|
|
|
|
2018-10-18 20:43:28 +00:00
|
|
|
result = get_shallow_commits(want_obj, depth,
|
2016-06-12 10:53:48 +00:00
|
|
|
SHALLOW, NOT_SHALLOW);
|
2019-01-15 19:40:27 +00:00
|
|
|
send_shallow(writer, result);
|
2016-06-12 10:53:48 +00:00
|
|
|
free_commit_list(result);
|
|
|
|
}
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
send_unshallow(writer, shallows, want_obj);
|
2016-06-12 10:53:45 +00:00
|
|
|
}
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
static void deepen_by_rev_list(struct packet_writer *writer, int ac,
|
|
|
|
const char **av,
|
2018-10-18 20:43:28 +00:00
|
|
|
struct object_array *shallows,
|
|
|
|
struct object_array *want_obj)
|
2016-06-12 10:53:58 +00:00
|
|
|
{
|
|
|
|
struct commit_list *result;
|
|
|
|
|
2018-08-20 18:24:34 +00:00
|
|
|
close_commit_graph(the_repository);
|
2016-06-12 10:53:58 +00:00
|
|
|
result = get_shallow_commits_by_rev_list(ac, av, SHALLOW, NOT_SHALLOW);
|
2019-01-15 19:40:27 +00:00
|
|
|
send_shallow(writer, result);
|
2016-06-12 10:53:58 +00:00
|
|
|
free_commit_list(result);
|
2019-01-15 19:40:27 +00:00
|
|
|
send_unshallow(writer, shallows, want_obj);
|
2018-03-15 17:31:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns 1 if a shallow list is sent or 0 otherwise */
|
2019-01-15 19:40:27 +00:00
|
|
|
static int send_shallow_list(struct packet_writer *writer,
|
|
|
|
int depth, int deepen_rev_list,
|
2018-03-15 17:31:28 +00:00
|
|
|
timestamp_t deepen_since,
|
|
|
|
struct string_list *deepen_not,
|
2018-12-18 21:24:35 +00:00
|
|
|
int deepen_relative,
|
2018-10-18 20:43:28 +00:00
|
|
|
struct object_array *shallows,
|
|
|
|
struct object_array *want_obj)
|
2018-03-15 17:31:28 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (depth > 0 && deepen_rev_list)
|
|
|
|
die("git upload-pack: deepen and deepen-since (or deepen-not) cannot be used together");
|
|
|
|
if (depth > 0) {
|
2019-01-15 19:40:27 +00:00
|
|
|
deepen(writer, depth, deepen_relative, shallows, want_obj);
|
2018-03-15 17:31:28 +00:00
|
|
|
ret = 1;
|
|
|
|
} else if (deepen_rev_list) {
|
|
|
|
struct argv_array av = ARGV_ARRAY_INIT;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
argv_array_push(&av, "rev-list");
|
|
|
|
if (deepen_since)
|
|
|
|
argv_array_pushf(&av, "--max-age=%"PRItime, deepen_since);
|
|
|
|
if (deepen_not->nr) {
|
|
|
|
argv_array_push(&av, "--not");
|
|
|
|
for (i = 0; i < deepen_not->nr; i++) {
|
|
|
|
struct string_list_item *s = deepen_not->items + i;
|
|
|
|
argv_array_push(&av, s->string);
|
|
|
|
}
|
|
|
|
argv_array_push(&av, "--not");
|
|
|
|
}
|
2018-10-18 20:43:28 +00:00
|
|
|
for (i = 0; i < want_obj->nr; i++) {
|
|
|
|
struct object *o = want_obj->objects[i].item;
|
2018-03-15 17:31:28 +00:00
|
|
|
argv_array_push(&av, oid_to_hex(&o->oid));
|
|
|
|
}
|
2019-01-15 19:40:27 +00:00
|
|
|
deepen_by_rev_list(writer, av.argc, av.argv, shallows, want_obj);
|
2018-03-15 17:31:28 +00:00
|
|
|
argv_array_clear(&av);
|
|
|
|
ret = 1;
|
|
|
|
} else {
|
|
|
|
if (shallows->nr > 0) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < shallows->nr; i++)
|
2018-07-18 19:20:27 +00:00
|
|
|
register_shallow(the_repository,
|
|
|
|
&shallows->objects[i].item->oid);
|
2018-03-15 17:31:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
shallow_nr += shallows->nr;
|
|
|
|
return ret;
|
2016-06-12 10:53:58 +00:00
|
|
|
}
|
|
|
|
|
2018-03-14 18:31:42 +00:00
|
|
|
static int process_shallow(const char *line, struct object_array *shallows)
|
|
|
|
{
|
|
|
|
const char *arg;
|
|
|
|
if (skip_prefix(line, "shallow ", &arg)) {
|
|
|
|
struct object_id oid;
|
|
|
|
struct object *object;
|
|
|
|
if (get_oid_hex(arg, &oid))
|
|
|
|
die("invalid shallow line: %s", line);
|
2018-06-29 01:21:51 +00:00
|
|
|
object = parse_object(the_repository, &oid);
|
2018-03-14 18:31:42 +00:00
|
|
|
if (!object)
|
|
|
|
return 1;
|
|
|
|
if (object->type != OBJ_COMMIT)
|
|
|
|
die("invalid shallow object %s", oid_to_hex(&oid));
|
|
|
|
if (!(object->flags & CLIENT_SHALLOW)) {
|
|
|
|
object->flags |= CLIENT_SHALLOW;
|
|
|
|
add_object_array(object, NULL, shallows);
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int process_deepen(const char *line, int *depth)
|
|
|
|
{
|
|
|
|
const char *arg;
|
|
|
|
if (skip_prefix(line, "deepen ", &arg)) {
|
|
|
|
char *end = NULL;
|
|
|
|
*depth = (int)strtol(arg, &end, 0);
|
|
|
|
if (!end || *end || *depth <= 0)
|
|
|
|
die("Invalid deepen: %s", line);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int process_deepen_since(const char *line, timestamp_t *deepen_since, int *deepen_rev_list)
|
|
|
|
{
|
|
|
|
const char *arg;
|
|
|
|
if (skip_prefix(line, "deepen-since ", &arg)) {
|
|
|
|
char *end = NULL;
|
|
|
|
*deepen_since = parse_timestamp(arg, &end, 0);
|
|
|
|
if (!end || *end || !deepen_since ||
|
|
|
|
/* revisions.c's max_age -1 is special */
|
|
|
|
*deepen_since == -1)
|
|
|
|
die("Invalid deepen-since: %s", line);
|
|
|
|
*deepen_rev_list = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int process_deepen_not(const char *line, struct string_list *deepen_not, int *deepen_rev_list)
|
|
|
|
{
|
|
|
|
const char *arg;
|
|
|
|
if (skip_prefix(line, "deepen-not ", &arg)) {
|
|
|
|
char *ref = NULL;
|
|
|
|
struct object_id oid;
|
2019-04-06 11:34:27 +00:00
|
|
|
if (expand_ref(the_repository, arg, strlen(arg), &oid, &ref) != 1)
|
2018-03-14 18:31:42 +00:00
|
|
|
die("git upload-pack: ambiguous deepen-not: %s", line);
|
|
|
|
string_list_append(deepen_not, ref);
|
|
|
|
free(ref);
|
|
|
|
*deepen_rev_list = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
2016-06-12 10:53:58 +00:00
|
|
|
}
|
|
|
|
|
2018-12-29 21:19:14 +00:00
|
|
|
static void receive_needs(struct packet_reader *reader, struct object_array *want_obj)
|
2005-07-04 22:29:17 +00:00
|
|
|
{
|
2010-08-29 02:04:17 +00:00
|
|
|
struct object_array shallows = OBJECT_ARRAY_INIT;
|
2016-06-12 10:54:03 +00:00
|
|
|
struct string_list deepen_not = STRING_LIST_INIT_DUP;
|
pkt-line: provide a LARGE_PACKET_MAX static buffer
Most of the callers of packet_read_line just read into a
static 1000-byte buffer (callers which handle arbitrary
binary data already use LARGE_PACKET_MAX). This works fine
in practice, because:
1. The only variable-sized data in these lines is a ref
name, and refs tend to be a lot shorter than 1000
characters.
2. When sending ref lines, git-core always limits itself
to 1000 byte packets.
However, the only limit given in the protocol specification
in Documentation/technical/protocol-common.txt is
LARGE_PACKET_MAX; the 1000 byte limit is mentioned only in
pack-protocol.txt, and then only describing what we write,
not as a specific limit for readers.
This patch lets us bump the 1000-byte limit to
LARGE_PACKET_MAX. Even though git-core will never write a
packet where this makes a difference, there are two good
reasons to do this:
1. Other git implementations may have followed
protocol-common.txt and used a larger maximum size. We
don't bump into it in practice because it would involve
very long ref names.
2. We may want to increase the 1000-byte limit one day.
Since packets are transferred before any capabilities,
it's difficult to do this in a backwards-compatible
way. But if we bump the size of buffer the readers can
handle, eventually older versions of git will be
obsolete enough that we can justify bumping the
writers, as well. We don't have plans to do this
anytime soon, but there is no reason not to start the
clock ticking now.
Just bumping all of the reading bufs to LARGE_PACKET_MAX
would waste memory. Instead, since most readers just read
into a temporary buffer anyway, let's provide a single
static buffer that all callers can use. We can further wrap
this detail away by having the packet_read_line wrapper just
use the buffer transparently and return a pointer to the
static storage. That covers most of the cases, and the
remaining ones already read into their own LARGE_PACKET_MAX
buffers.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-20 20:02:57 +00:00
|
|
|
int depth = 0;
|
2011-08-05 20:54:06 +00:00
|
|
|
int has_non_tip = 0;
|
2017-04-26 19:29:31 +00:00
|
|
|
timestamp_t deepen_since = 0;
|
2016-06-12 10:53:58 +00:00
|
|
|
int deepen_rev_list = 0;
|
2018-12-18 21:24:35 +00:00
|
|
|
int deepen_relative = 0;
|
2019-01-15 19:40:27 +00:00
|
|
|
struct packet_writer writer;
|
2005-07-04 22:29:17 +00:00
|
|
|
|
2009-06-09 23:50:18 +00:00
|
|
|
shallow_nr = 0;
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_init(&writer, 1);
|
2005-07-04 22:29:17 +00:00
|
|
|
for (;;) {
|
2005-10-25 01:59:18 +00:00
|
|
|
struct object *o;
|
2012-01-08 21:06:19 +00:00
|
|
|
const char *features;
|
2017-05-06 22:10:28 +00:00
|
|
|
struct object_id oid_buf;
|
2016-06-12 10:53:49 +00:00
|
|
|
const char *arg;
|
|
|
|
|
2005-10-19 21:27:01 +00:00
|
|
|
reset_timeout();
|
2018-12-29 21:19:14 +00:00
|
|
|
if (packet_reader_read(reader) != PACKET_READ_NORMAL)
|
2006-10-30 19:09:06 +00:00
|
|
|
break;
|
2005-10-05 21:49:54 +00:00
|
|
|
|
2018-12-29 21:19:14 +00:00
|
|
|
if (process_shallow(reader->line, &shallows))
|
2006-10-30 19:09:06 +00:00
|
|
|
continue;
|
2018-12-29 21:19:14 +00:00
|
|
|
if (process_deepen(reader->line, &depth))
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
continue;
|
2018-12-29 21:19:14 +00:00
|
|
|
if (process_deepen_since(reader->line, &deepen_since, &deepen_rev_list))
|
2016-06-12 10:53:58 +00:00
|
|
|
continue;
|
2018-12-29 21:19:14 +00:00
|
|
|
if (process_deepen_not(reader->line, &deepen_not, &deepen_rev_list))
|
2016-06-12 10:54:03 +00:00
|
|
|
continue;
|
2018-03-14 18:31:42 +00:00
|
|
|
|
2018-12-29 21:19:14 +00:00
|
|
|
if (skip_prefix(reader->line, "filter ", &arg)) {
|
2017-12-08 15:58:39 +00:00
|
|
|
if (!filter_capability_requested)
|
|
|
|
die("git upload-pack: filtering capability not negotiated");
|
|
|
|
parse_list_objects_filter(&filter_options, arg);
|
|
|
|
continue;
|
|
|
|
}
|
2018-05-08 06:59:15 +00:00
|
|
|
|
2018-12-29 21:19:14 +00:00
|
|
|
if (!skip_prefix(reader->line, "want ", &arg) ||
|
2018-05-02 00:25:51 +00:00
|
|
|
parse_oid_hex(arg, &oid_buf, &features))
|
2008-08-31 16:39:19 +00:00
|
|
|
die("git upload-pack: protocol error, "
|
2018-12-29 21:19:14 +00:00
|
|
|
"expected to get object ID, not '%s'", reader->line);
|
2012-01-08 21:06:19 +00:00
|
|
|
|
fetch, upload-pack: --deepen=N extends shallow boundary by N commits
In git-fetch, --depth argument is always relative with the latest
remote refs. This makes it a bit difficult to cover this use case,
where the user wants to make the shallow history, say 3 levels
deeper. It would work if remote refs have not moved yet, but nobody
can guarantee that, especially when that use case is performed a
couple months after the last clone or "git fetch --depth". Also,
modifying shallow boundary using --depth does not work well with
clones created by --since or --not.
This patch fixes that. A new argument --deepen=<N> will add <N> more (*)
parent commits to the current history regardless of where remote refs
are.
Have/Want negotiation is still respected. So if remote refs move, the
server will send two chunks: one between "have" and "want" and another
to extend shallow history. In theory, the client could send no "want"s
in order to get the second chunk only. But the protocol does not allow
that. Either you send no want lines, which means ls-remote; or you
have to send at least one want line that carries deep-relative to the
server..
The main work was done by Dongcan Jiang. I fixed it up here and there.
And of course all the bugs belong to me.
(*) We could even support --deepen=<N> where <N> is negative. In that
case we can cut some history from the shallow clone. This operation
(and --depth=<shorter depth>) does not require interaction with remote
side (and more complicated to implement as a result).
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Dongcan Jiang <dongcan.jiang@gmail.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-12 10:54:09 +00:00
|
|
|
if (parse_feature_request(features, "deepen-relative"))
|
|
|
|
deepen_relative = 1;
|
2012-01-08 21:06:19 +00:00
|
|
|
if (parse_feature_request(features, "multi_ack_detailed"))
|
2009-10-31 00:47:25 +00:00
|
|
|
multi_ack = 2;
|
2012-01-08 21:06:19 +00:00
|
|
|
else if (parse_feature_request(features, "multi_ack"))
|
2005-10-28 02:49:16 +00:00
|
|
|
multi_ack = 1;
|
2012-01-08 21:06:19 +00:00
|
|
|
if (parse_feature_request(features, "no-done"))
|
2011-03-29 19:29:10 +00:00
|
|
|
no_done = 1;
|
2012-01-08 21:06:19 +00:00
|
|
|
if (parse_feature_request(features, "thin-pack"))
|
2006-02-20 08:38:39 +00:00
|
|
|
use_thin_pack = 1;
|
2012-01-08 21:06:19 +00:00
|
|
|
if (parse_feature_request(features, "ofs-delta"))
|
2006-09-26 15:27:39 +00:00
|
|
|
use_ofs_delta = 1;
|
2012-01-08 21:06:19 +00:00
|
|
|
if (parse_feature_request(features, "side-band-64k"))
|
2006-09-10 23:27:08 +00:00
|
|
|
use_sideband = LARGE_PACKET_MAX;
|
2012-01-08 21:06:19 +00:00
|
|
|
else if (parse_feature_request(features, "side-band"))
|
2006-09-10 23:27:08 +00:00
|
|
|
use_sideband = DEFAULT_PACKET_MAX;
|
2012-01-08 21:06:19 +00:00
|
|
|
if (parse_feature_request(features, "no-progress"))
|
2007-02-23 19:03:10 +00:00
|
|
|
no_progress = 1;
|
2012-01-08 21:06:19 +00:00
|
|
|
if (parse_feature_request(features, "include-tag"))
|
2008-03-04 03:27:33 +00:00
|
|
|
use_include_tag = 1;
|
2018-03-28 20:33:03 +00:00
|
|
|
if (allow_filter && parse_feature_request(features, "filter"))
|
2017-12-08 15:58:39 +00:00
|
|
|
filter_capability_requested = 1;
|
2005-10-25 01:59:18 +00:00
|
|
|
|
2018-06-29 01:21:51 +00:00
|
|
|
o = parse_object(the_repository, &oid_buf);
|
2017-02-23 18:43:03 +00:00
|
|
|
if (!o) {
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_error(&writer,
|
|
|
|
"upload-pack: not our ref %s",
|
|
|
|
oid_to_hex(&oid_buf));
|
2010-07-31 20:11:46 +00:00
|
|
|
die("git upload-pack: not our ref %s",
|
2017-05-06 22:10:28 +00:00
|
|
|
oid_to_hex(&oid_buf));
|
2017-02-23 18:43:03 +00:00
|
|
|
}
|
2005-10-25 01:59:18 +00:00
|
|
|
if (!(o->flags & WANTED)) {
|
|
|
|
o->flags |= WANTED;
|
2016-11-11 17:23:48 +00:00
|
|
|
if (!((allow_unadvertised_object_request & ALLOW_ANY_SHA1) == ALLOW_ANY_SHA1
|
|
|
|
|| is_our_ref(o)))
|
2011-08-05 20:54:06 +00:00
|
|
|
has_non_tip = 1;
|
2018-10-18 20:43:28 +00:00
|
|
|
add_object_array(o, NULL, want_obj);
|
2005-10-25 01:59:18 +00:00
|
|
|
}
|
2005-07-04 22:29:17 +00:00
|
|
|
}
|
2009-06-16 18:41:16 +00:00
|
|
|
|
2011-08-05 20:54:06 +00:00
|
|
|
/*
|
|
|
|
* We have sent all our refs already, and the other end
|
|
|
|
* should have chosen out of them. When we are operating
|
|
|
|
* in the stateless RPC mode, however, their choice may
|
|
|
|
* have been based on the set of older refs advertised
|
|
|
|
* by another process that handled the initial request.
|
|
|
|
*/
|
|
|
|
if (has_non_tip)
|
upload-pack: send ERR packet for non-tip objects
Commit bdb31eada7 (upload-pack: report "not our ref" to client,
2017-02-23) catches the case where a client asks for an object we don't
have, and issues a message that the client can show to the user (in
addition to dying and writing to stderr).
There's a similar case (with the same message) when the client asks for
an object which we _do_ have, but which isn't a ref tip (or isn't
reachable, when uploadpack.allowReachableSHA1InWant is true). Let's give
that one the same treatment, for the same reason (namely that it's more
informative to the client than just hanging up, since they won't see our
stderr over some protocols).
There are two tests here. We cover it most directly in t5530 by invoking
upload-pack, which matches the existing "not our ref" test.
But a more end-to-end check is that "git fetch" actually shows the
message to the client. We're already checking in t5516 that this case
fails, so we can just check stderr there, too. Note that even after we
started ignoring SIGPIPE in 8bf4becf0c, this could in theory still be
racy as described in that commit (because we die() on write failures
before pumping the connection for any ERR packets).
In practice this should be OK for this case. The server will not
actually check reachability until it has received our whole group of
"want" lines. And since we have no objects in the repository, we won't
send any "have" lines, meaning we're always waiting to read the server
response.
Note also that this case cannot happen in the v2 protocol, since it
allows any available object to be requested. However, we don't have to
take any steps to protect against the upcoming GIT_TEST_PROTOCOL_VERSION
in our tests:
- the tests in t5516 would already need to be skipped under v2, and
that is covered by ab0c5f5096 (tests: always test fetch of
unreachable with v0, 2019-02-25)
- the tests in t5530 invoke upload-pack directly, which will continue
to default to v0. Eventually we may have a test setting which uses
v2 even for bare upload-pack calls, but we can't override it here
until we know what the setting looks like.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-04-13 05:53:34 +00:00
|
|
|
check_non_tip(want_obj, &writer);
|
2011-08-05 20:54:06 +00:00
|
|
|
|
2009-06-16 18:41:16 +00:00
|
|
|
if (!use_sideband && daemon_mode)
|
|
|
|
no_progress = 1;
|
|
|
|
|
2016-06-12 10:53:58 +00:00
|
|
|
if (depth == 0 && !deepen_rev_list && shallows.nr == 0)
|
2006-10-30 19:09:53 +00:00
|
|
|
return;
|
2016-06-12 10:53:58 +00:00
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
if (send_shallow_list(&writer, depth, deepen_rev_list, deepen_since,
|
2018-12-18 21:24:35 +00:00
|
|
|
&deepen_not, deepen_relative, &shallows,
|
|
|
|
want_obj))
|
2018-03-15 17:31:28 +00:00
|
|
|
packet_flush(1);
|
2017-09-22 23:34:52 +00:00
|
|
|
object_array_clear(&shallows);
|
2005-07-04 22:29:17 +00:00
|
|
|
}
|
|
|
|
|
upload/receive-pack: allow hiding ref hierarchies
A repository may have refs that are only used for its internal
bookkeeping purposes that should not be exposed to the others that
come over the network.
Teach upload-pack to omit some refs from its initial advertisement
by paying attention to the uploadpack.hiderefs multi-valued
configuration variable. Do the same to receive-pack via the
receive.hiderefs variable. As a convenient short-hand, allow using
transfer.hiderefs to set the value to both of these variables.
Any ref that is under the hierarchies listed on the value of these
variable is excluded from responses to requests made by "ls-remote",
"fetch", etc. (for upload-pack) and "push" (for receive-pack).
Because these hidden refs do not count as OUR_REF, an attempt to
fetch objects at the tip of them will be rejected, and because these
refs do not get advertised, "git push :" will not see local branches
that have the same name as them as "matching" ones to be sent.
An attempt to update/delete these hidden refs with an explicit
refspec, e.g. "git push origin :refs/hidden/22", is rejected. This
is not a new restriction. To the pusher, it would appear that there
is no such ref, so its push request will conclude with "Now that I
sent you all the data, it is time for you to update the refs. I saw
that the ref did not exist when I started pushing, and I want the
result to point at this commit". The receiving end will apply the
compare-and-swap rule to this request and rejects the push with
"Well, your update request conflicts with somebody else; I see there
is such a ref.", which is the right thing to do. Otherwise a push to
a hidden ref will always be "the last one wins", which is not a good
default.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-19 00:08:30 +00:00
|
|
|
/* return non-zero if the ref is hidden, otherwise 0 */
|
2015-11-03 07:58:16 +00:00
|
|
|
static int mark_our_ref(const char *refname, const char *refname_full,
|
|
|
|
const struct object_id *oid)
|
2013-01-18 23:48:49 +00:00
|
|
|
{
|
2015-05-25 18:39:12 +00:00
|
|
|
struct object *o = lookup_unknown_object(oid->hash);
|
upload/receive-pack: allow hiding ref hierarchies
A repository may have refs that are only used for its internal
bookkeeping purposes that should not be exposed to the others that
come over the network.
Teach upload-pack to omit some refs from its initial advertisement
by paying attention to the uploadpack.hiderefs multi-valued
configuration variable. Do the same to receive-pack via the
receive.hiderefs variable. As a convenient short-hand, allow using
transfer.hiderefs to set the value to both of these variables.
Any ref that is under the hierarchies listed on the value of these
variable is excluded from responses to requests made by "ls-remote",
"fetch", etc. (for upload-pack) and "push" (for receive-pack).
Because these hidden refs do not count as OUR_REF, an attempt to
fetch objects at the tip of them will be rejected, and because these
refs do not get advertised, "git push :" will not see local branches
that have the same name as them as "matching" ones to be sent.
An attempt to update/delete these hidden refs with an explicit
refspec, e.g. "git push origin :refs/hidden/22", is rejected. This
is not a new restriction. To the pusher, it would appear that there
is no such ref, so its push request will conclude with "Now that I
sent you all the data, it is time for you to update the refs. I saw
that the ref did not exist when I started pushing, and I want the
result to point at this commit". The receiving end will apply the
compare-and-swap rule to this request and rejects the push with
"Well, your update request conflicts with somebody else; I see there
is such a ref.", which is the right thing to do. Otherwise a push to
a hidden ref will always be "the last one wins", which is not a good
default.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-19 00:08:30 +00:00
|
|
|
|
2015-11-03 07:58:16 +00:00
|
|
|
if (ref_is_hidden(refname, refname_full)) {
|
2013-01-29 05:49:57 +00:00
|
|
|
o->flags |= HIDDEN_REF;
|
upload/receive-pack: allow hiding ref hierarchies
A repository may have refs that are only used for its internal
bookkeeping purposes that should not be exposed to the others that
come over the network.
Teach upload-pack to omit some refs from its initial advertisement
by paying attention to the uploadpack.hiderefs multi-valued
configuration variable. Do the same to receive-pack via the
receive.hiderefs variable. As a convenient short-hand, allow using
transfer.hiderefs to set the value to both of these variables.
Any ref that is under the hierarchies listed on the value of these
variable is excluded from responses to requests made by "ls-remote",
"fetch", etc. (for upload-pack) and "push" (for receive-pack).
Because these hidden refs do not count as OUR_REF, an attempt to
fetch objects at the tip of them will be rejected, and because these
refs do not get advertised, "git push :" will not see local branches
that have the same name as them as "matching" ones to be sent.
An attempt to update/delete these hidden refs with an explicit
refspec, e.g. "git push origin :refs/hidden/22", is rejected. This
is not a new restriction. To the pusher, it would appear that there
is no such ref, so its push request will conclude with "Now that I
sent you all the data, it is time for you to update the refs. I saw
that the ref did not exist when I started pushing, and I want the
result to point at this commit". The receiving end will apply the
compare-and-swap rule to this request and rejects the push with
"Well, your update request conflicts with somebody else; I see there
is such a ref.", which is the right thing to do. Otherwise a push to
a hidden ref will always be "the last one wins", which is not a good
default.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-19 00:08:30 +00:00
|
|
|
return 1;
|
2013-01-29 05:49:57 +00:00
|
|
|
}
|
2013-01-29 04:45:43 +00:00
|
|
|
o->flags |= OUR_REF;
|
2013-01-18 23:48:49 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-03 07:58:16 +00:00
|
|
|
static int check_ref(const char *refname_full, const struct object_id *oid,
|
2015-05-25 18:39:12 +00:00
|
|
|
int flag, void *cb_data)
|
upload-pack: fix transfer.hiderefs over smart-http
When upload-pack advertises the refs (either for a normal,
non-stateless request, or for the initial contact in a
stateless one), we call for_each_ref with the send_ref
function as its callback. send_ref, in turn, calls
mark_our_ref, which checks whether the ref is hidden, and
sets OUR_REF or HIDDEN_REF on the object as appropriate. If
it is hidden, mark_our_ref also returns "1" to signal
send_ref that the ref should not be advertised.
If we are not advertising refs, (i.e., the follow-up
invocation by an http client to send its "want" lines), we
use mark_our_ref directly as a callback to for_each_ref. Its
marking does the right thing, but when it then returns "1"
to for_each_ref, the latter interprets this as an error and
stops iterating. As a result, we skip marking all of the
refs that come lexicographically after it. Any "want" lines
from the client asking for those objects will fail, as they
were not properly marked with OUR_REF.
To solve this, we introduce a wrapper callback around
mark_our_ref which always returns 0 (even if the ref is
hidden, we want to keep iterating). We also tweak the
signature of mark_our_ref to exclude unnecessary parameters
that were present only to conform to the callback interface.
This should make it less likely for somebody to accidentally
use it as a callback in the future.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-03-13 04:42:12 +00:00
|
|
|
{
|
2015-11-03 07:58:16 +00:00
|
|
|
const char *refname = strip_namespace(refname_full);
|
|
|
|
|
|
|
|
mark_our_ref(refname, refname_full, oid);
|
upload-pack: fix transfer.hiderefs over smart-http
When upload-pack advertises the refs (either for a normal,
non-stateless request, or for the initial contact in a
stateless one), we call for_each_ref with the send_ref
function as its callback. send_ref, in turn, calls
mark_our_ref, which checks whether the ref is hidden, and
sets OUR_REF or HIDDEN_REF on the object as appropriate. If
it is hidden, mark_our_ref also returns "1" to signal
send_ref that the ref should not be advertised.
If we are not advertising refs, (i.e., the follow-up
invocation by an http client to send its "want" lines), we
use mark_our_ref directly as a callback to for_each_ref. Its
marking does the right thing, but when it then returns "1"
to for_each_ref, the latter interprets this as an error and
stops iterating. As a result, we skip marking all of the
refs that come lexicographically after it. Any "want" lines
from the client asking for those objects will fail, as they
were not properly marked with OUR_REF.
To solve this, we introduce a wrapper callback around
mark_our_ref which always returns 0 (even if the ref is
hidden, we want to keep iterating). We also tweak the
signature of mark_our_ref to exclude unnecessary parameters
that were present only to conform to the callback interface.
This should make it less likely for somebody to accidentally
use it as a callback in the future.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-03-13 04:42:12 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-17 23:17:33 +00:00
|
|
|
static void format_symref_info(struct strbuf *buf, struct string_list *symref)
|
|
|
|
{
|
|
|
|
struct string_list_item *item;
|
|
|
|
|
|
|
|
if (!symref->nr)
|
|
|
|
return;
|
|
|
|
for_each_string_list_item(item, symref)
|
|
|
|
strbuf_addf(buf, " symref=%s:%s", item->string, (char *)item->util);
|
|
|
|
}
|
|
|
|
|
2015-05-25 18:39:12 +00:00
|
|
|
static int send_ref(const char *refname, const struct object_id *oid,
|
|
|
|
int flag, void *cb_data)
|
2005-07-04 20:26:53 +00:00
|
|
|
{
|
2006-10-30 19:09:06 +00:00
|
|
|
static const char *capabilities = "multi_ack thin-pack side-band"
|
fetch, upload-pack: --deepen=N extends shallow boundary by N commits
In git-fetch, --depth argument is always relative with the latest
remote refs. This makes it a bit difficult to cover this use case,
where the user wants to make the shallow history, say 3 levels
deeper. It would work if remote refs have not moved yet, but nobody
can guarantee that, especially when that use case is performed a
couple months after the last clone or "git fetch --depth". Also,
modifying shallow boundary using --depth does not work well with
clones created by --since or --not.
This patch fixes that. A new argument --deepen=<N> will add <N> more (*)
parent commits to the current history regardless of where remote refs
are.
Have/Want negotiation is still respected. So if remote refs move, the
server will send two chunks: one between "have" and "want" and another
to extend shallow history. In theory, the client could send no "want"s
in order to get the second chunk only. But the protocol does not allow
that. Either you send no want lines, which means ls-remote; or you
have to send at least one want line that carries deep-relative to the
server..
The main work was done by Dongcan Jiang. I fixed it up here and there.
And of course all the bugs belong to me.
(*) We could even support --deepen=<N> where <N> is negative. In that
case we can cut some history from the shallow clone. This operation
(and --depth=<shorter depth>) does not require interaction with remote
side (and more complicated to implement as a result).
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Dongcan Jiang <dongcan.jiang@gmail.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-12 10:54:09 +00:00
|
|
|
" side-band-64k ofs-delta shallow deepen-since deepen-not"
|
|
|
|
" deepen-relative no-progress include-tag multi_ack_detailed";
|
2011-07-08 23:13:32 +00:00
|
|
|
const char *refname_nons = strip_namespace(refname);
|
2015-05-25 18:39:13 +00:00
|
|
|
struct object_id peeled;
|
2006-02-18 00:14:52 +00:00
|
|
|
|
2015-11-03 07:58:16 +00:00
|
|
|
if (mark_our_ref(refname_nons, refname, oid))
|
upload/receive-pack: allow hiding ref hierarchies
A repository may have refs that are only used for its internal
bookkeeping purposes that should not be exposed to the others that
come over the network.
Teach upload-pack to omit some refs from its initial advertisement
by paying attention to the uploadpack.hiderefs multi-valued
configuration variable. Do the same to receive-pack via the
receive.hiderefs variable. As a convenient short-hand, allow using
transfer.hiderefs to set the value to both of these variables.
Any ref that is under the hierarchies listed on the value of these
variable is excluded from responses to requests made by "ls-remote",
"fetch", etc. (for upload-pack) and "push" (for receive-pack).
Because these hidden refs do not count as OUR_REF, an attempt to
fetch objects at the tip of them will be rejected, and because these
refs do not get advertised, "git push :" will not see local branches
that have the same name as them as "matching" ones to be sent.
An attempt to update/delete these hidden refs with an explicit
refspec, e.g. "git push origin :refs/hidden/22", is rejected. This
is not a new restriction. To the pusher, it would appear that there
is no such ref, so its push request will conclude with "Now that I
sent you all the data, it is time for you to update the refs. I saw
that the ref did not exist when I started pushing, and I want the
result to point at this commit". The receiving end will apply the
compare-and-swap rule to this request and rejects the push with
"Well, your update request conflicts with somebody else; I see there
is such a ref.", which is the right thing to do. Otherwise a push to
a hidden ref will always be "the last one wins", which is not a good
default.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-19 00:08:30 +00:00
|
|
|
return 0;
|
2013-01-18 23:48:49 +00:00
|
|
|
|
2013-09-17 23:17:33 +00:00
|
|
|
if (capabilities) {
|
|
|
|
struct strbuf symref_info = STRBUF_INIT;
|
|
|
|
|
|
|
|
format_symref_info(&symref_info, cb_data);
|
2017-12-08 15:58:39 +00:00
|
|
|
packet_write_fmt(1, "%s %s%c%s%s%s%s%s%s agent=%s\n",
|
2015-05-25 18:39:12 +00:00
|
|
|
oid_to_hex(oid), refname_nons,
|
2011-03-29 17:24:59 +00:00
|
|
|
0, capabilities,
|
2015-05-21 20:23:38 +00:00
|
|
|
(allow_unadvertised_object_request & ALLOW_TIP_SHA1) ?
|
|
|
|
" allow-tip-sha1-in-want" : "",
|
2015-05-21 20:23:39 +00:00
|
|
|
(allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1) ?
|
|
|
|
" allow-reachable-sha1-in-want" : "",
|
2012-08-03 16:19:16 +00:00
|
|
|
stateless_rpc ? " no-done" : "",
|
2013-09-17 23:17:33 +00:00
|
|
|
symref_info.buf,
|
2018-03-28 20:33:03 +00:00
|
|
|
allow_filter ? " filter" : "",
|
2012-08-03 16:19:16 +00:00
|
|
|
git_user_agent_sanitized());
|
2013-09-17 23:17:33 +00:00
|
|
|
strbuf_release(&symref_info);
|
|
|
|
} else {
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "%s %s\n", oid_to_hex(oid), refname_nons);
|
2013-09-17 23:17:33 +00:00
|
|
|
}
|
2005-10-28 03:56:41 +00:00
|
|
|
capabilities = NULL;
|
2017-10-15 22:07:02 +00:00
|
|
|
if (!peel_ref(refname, &peeled))
|
2016-10-16 23:20:29 +00:00
|
|
|
packet_write_fmt(1, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);
|
2005-07-04 20:26:53 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-25 18:39:10 +00:00
|
|
|
static int find_symref(const char *refname, const struct object_id *oid,
|
|
|
|
int flag, void *cb_data)
|
2013-09-17 23:17:33 +00:00
|
|
|
{
|
|
|
|
const char *symref_target;
|
|
|
|
struct string_list_item *item;
|
|
|
|
|
|
|
|
if ((flag & REF_ISSYMREF) == 0)
|
|
|
|
return 0;
|
2017-09-23 09:45:04 +00:00
|
|
|
symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag);
|
2013-09-17 23:17:33 +00:00
|
|
|
if (!symref_target || (flag & REF_ISSYMREF) == 0)
|
|
|
|
die("'%s' is a symref but it is not?", refname);
|
upload-pack: strip namespace from symref data
Since 7171d8c15f (upload-pack: send symbolic ref information as
capability, 2013-09-17), we've sent cloning and fetching clients special
information about which branch HEAD is pointing to, so that they don't
have to guess based on matching up commit ids.
However, this feature has never worked properly with the GIT_NAMESPACE
feature. Because upload-pack uses head_ref_namespaced(find_symref), we
do find and report on refs/namespaces/foo/HEAD instead of the actual
HEAD of the repo. This makes sense, since the branch pointed to by the
top-level HEAD may not be advertised at all. But we do two things wrong:
1. We report the full name refs/namespaces/foo/HEAD, instead of just
HEAD. Meaning no client is going to bother doing anything with that
symref, since we're not otherwise advertising it.
2. We report the symref destination using its full name (e.g.,
refs/namespaces/foo/refs/heads/master). That's similarly useless to
the client, who only saw "refs/heads/master" in the advertisement.
We should be stripping the namespace prefix off of both places (which
this patch fixes).
Likely nobody noticed because we tend to do the right thing anyway. Bug
(1) means that we said nothing about HEAD (just refs/namespace/foo/HEAD).
And so the client half of the code, from a45b5f0552 (connect: annotate
refs with their symref information in get_remote_head(), 2013-09-17),
does not annotate HEAD, and we use the fallback in guess_remote_head(),
matching refs by object id. Which is usually right. It only falls down
in ambiguous cases, like the one laid out in the included test.
This also means that we don't have to worry about breaking anybody who
was putting pre-stripped names into their namespace symrefs when we fix
bug (2). Because of bug (1), nobody would have been using the symref we
advertised in the first place (not to mention that those symrefs would
have appeared broken for any non-namespaced access).
Note that we have separate fixes here for the v0 and v2 protocols. The
symref advertisement moved in v2 to be a part of the ls-refs command.
This actually gets part (1) right, since the symref annotation
piggy-backs on the existing ref advertisement, which is properly
stripped. But it still needs a fix for part (2). The included tests
cover both protocols.
Reported-by: Bryan Turner <bturner@atlassian.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-23 06:11:21 +00:00
|
|
|
item = string_list_append(cb_data, strip_namespace(refname));
|
|
|
|
item->util = xstrdup(strip_namespace(symref_target));
|
2013-09-17 23:17:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
upload/receive-pack: allow hiding ref hierarchies
A repository may have refs that are only used for its internal
bookkeeping purposes that should not be exposed to the others that
come over the network.
Teach upload-pack to omit some refs from its initial advertisement
by paying attention to the uploadpack.hiderefs multi-valued
configuration variable. Do the same to receive-pack via the
receive.hiderefs variable. As a convenient short-hand, allow using
transfer.hiderefs to set the value to both of these variables.
Any ref that is under the hierarchies listed on the value of these
variable is excluded from responses to requests made by "ls-remote",
"fetch", etc. (for upload-pack) and "push" (for receive-pack).
Because these hidden refs do not count as OUR_REF, an attempt to
fetch objects at the tip of them will be rejected, and because these
refs do not get advertised, "git push :" will not see local branches
that have the same name as them as "matching" ones to be sent.
An attempt to update/delete these hidden refs with an explicit
refspec, e.g. "git push origin :refs/hidden/22", is rejected. This
is not a new restriction. To the pusher, it would appear that there
is no such ref, so its push request will conclude with "Now that I
sent you all the data, it is time for you to update the refs. I saw
that the ref did not exist when I started pushing, and I want the
result to point at this commit". The receiving end will apply the
compare-and-swap rule to this request and rejects the push with
"Well, your update request conflicts with somebody else; I see there
is such a ref.", which is the right thing to do. Otherwise a push to
a hidden ref will always be "the last one wins", which is not a good
default.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-19 00:08:30 +00:00
|
|
|
static int upload_pack_config(const char *var, const char *value, void *unused)
|
|
|
|
{
|
2015-05-21 20:23:38 +00:00
|
|
|
if (!strcmp("uploadpack.allowtipsha1inwant", var)) {
|
|
|
|
if (git_config_bool(var, value))
|
|
|
|
allow_unadvertised_object_request |= ALLOW_TIP_SHA1;
|
|
|
|
else
|
|
|
|
allow_unadvertised_object_request &= ~ALLOW_TIP_SHA1;
|
2015-05-21 20:23:39 +00:00
|
|
|
} else if (!strcmp("uploadpack.allowreachablesha1inwant", var)) {
|
|
|
|
if (git_config_bool(var, value))
|
|
|
|
allow_unadvertised_object_request |= ALLOW_REACHABLE_SHA1;
|
|
|
|
else
|
|
|
|
allow_unadvertised_object_request &= ~ALLOW_REACHABLE_SHA1;
|
2016-11-11 17:23:48 +00:00
|
|
|
} else if (!strcmp("uploadpack.allowanysha1inwant", var)) {
|
|
|
|
if (git_config_bool(var, value))
|
|
|
|
allow_unadvertised_object_request |= ALLOW_ANY_SHA1;
|
|
|
|
else
|
|
|
|
allow_unadvertised_object_request &= ~ALLOW_ANY_SHA1;
|
2015-05-21 20:23:38 +00:00
|
|
|
} else if (!strcmp("uploadpack.keepalive", var)) {
|
2013-09-08 09:01:31 +00:00
|
|
|
keepalive = git_config_int(var, value);
|
|
|
|
if (!keepalive)
|
|
|
|
keepalive = -1;
|
2017-12-08 15:58:39 +00:00
|
|
|
} else if (!strcmp("uploadpack.allowfilter", var)) {
|
2018-03-28 20:33:03 +00:00
|
|
|
allow_filter = git_config_bool(var, value);
|
2018-06-27 22:30:17 +00:00
|
|
|
} else if (!strcmp("uploadpack.allowrefinwant", var)) {
|
|
|
|
allow_ref_in_want = git_config_bool(var, value);
|
2019-01-16 19:28:14 +00:00
|
|
|
} else if (!strcmp("uploadpack.allowsidebandall", var)) {
|
|
|
|
allow_sideband_all = git_config_bool(var, value);
|
Honor core.precomposeUnicode in more places
On Mac's HFS where git sets core.precomposeUnicode to true automatically
by git init/clone, when a user creates a simple unicode refname (in NFC
format) such as españa:
$ git branch españa
different commands would display the branch name differently. For
example, git branch, git log --decorate, and git fast-export all used
65 73 70 61 c3 b1 61 (or "espa\xc3\xb1a")
(NFC form) while show-ref would use
65 73 70 61 6e cc 83 61 (or "espan\xcc\x83a")
(NFD form). A stress test for git filter-repo was tripped up by this
inconsistency, though digging in I found that the problems could
compound; for example, if the user ran
$ git pack-refs --all
and then tried to check out the branch, they would be met with:
$ git checkout españa
error: pathspec 'españa' did not match any file(s) known to git
$ git checkout españa --
fatal: invalid reference: españa
$ git branch
españa
* master
Note that the user could run the `git branch` command first and copy and
paste the `españa` portion of the output and still see the same two
errors. Also, if the user added --no-prune to the pack-refs command,
then they would see three branches: master, españa, and españa (those
last two are NFC vs. NFD forms, even if they render the same).
Further, if the user had the `españa` branch checked out before
running `git pack-refs --all`, the user would be greeted with (note
that I'm trimming trailing output with an ellipsis):
$ git rev-parse HEAD
fatal: ambiguous argument 'HEAD': unknown revision or path...
$ git status
On branch españa
No commits yet...
Or worse, if the user didn't check this stuff first, running `git
commit` will create a new commit with all changes of all of history
being squashed into it.
In addition to pack-refs, one could also get into this state with
upload-pack or anything that calls either pack-refs or upload-pack (e.g.
gc or clone).
Add code in a few places (pack-refs, show-ref, upload-pack) to check and
honor the setting of core.precomposeUnicode to avoid these bugs.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-04-25 14:58:54 +00:00
|
|
|
} else if (!strcmp("core.precomposeunicode", var)) {
|
|
|
|
precomposed_unicode = git_config_bool(var, value);
|
2013-09-08 09:01:31 +00:00
|
|
|
}
|
upload-pack: fix broken if/else chain in config callback
The upload_pack_config() callback uses an if/else chain
like:
if (!strcmp(var, "a"))
...
else if (!strcmp(var, "b"))
...
etc
This works as long as the conditions are mutually exclusive,
but one of them is not. 20b20a22f8 (upload-pack: provide a
hook for running pack-objects, 2016-05-18) added:
else if (current_config_scope() != CONFIG_SCOPE_REPO) {
... check some more options ...
}
That was fine in that commit, because it came at the end of
the chain. But later, 10ac85c785 (upload-pack: add object
filtering for partial clone, 2017-12-08) did this:
else if (current_config_scope() != CONFIG_SCOPE_REPO) {
... check some more options ...
} else if (!strcmp("uploadpack.allowfilter", var))
...
We'd always check the scope condition first, meaning we'd
_only_ respect allowfilter when it's in the repo config. You
can see this with:
git -c uploadpack.allowfilter=true upload-pack . | head -1
which will not advertise the filter capability (but will
after this patch). We never noticed because:
- our tests always set it in the repo config
- in protocol v2, we use a different code path that
actually calls repo_config_get_bool() separately, so
that _does_ work. Real-world people experimenting with
this may be using v2.
The more recent uploadpack.allowrefinwant option is in the
same boat.
There are a few possible fixes:
1. Bump the scope conditional back to the bottom of the
chain. But that just means somebody else is likely to
make the same mistake later.
2. Make the conditional more like the others. I.e.:
else if (!current_config_scope() != CONFIG_SCOPE_REPO &&
!strcmp(var, "uploadpack.notallowedinrepo"))
This works, but the idea of the original structure was
that we may grow multiple sensitive options like this.
3. Pull it out of the chain entirely. The chain mostly
serves to avoid extra strcmp() calls after we've found
a match. But it's not worth caring about those. In the
worst case, when there isn't a match, we're already
hitting every strcmp (and this happens regularly for
stuff like "core.bare", etc).
This patch does (3).
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Josh Steadmon <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-24 07:27:52 +00:00
|
|
|
|
|
|
|
if (current_config_scope() != CONFIG_SCOPE_REPO) {
|
|
|
|
if (!strcmp("uploadpack.packobjectshook", var))
|
|
|
|
return git_config_string(&pack_objects_hook, var, value);
|
|
|
|
}
|
|
|
|
|
upload/receive-pack: allow hiding ref hierarchies
A repository may have refs that are only used for its internal
bookkeeping purposes that should not be exposed to the others that
come over the network.
Teach upload-pack to omit some refs from its initial advertisement
by paying attention to the uploadpack.hiderefs multi-valued
configuration variable. Do the same to receive-pack via the
receive.hiderefs variable. As a convenient short-hand, allow using
transfer.hiderefs to set the value to both of these variables.
Any ref that is under the hierarchies listed on the value of these
variable is excluded from responses to requests made by "ls-remote",
"fetch", etc. (for upload-pack) and "push" (for receive-pack).
Because these hidden refs do not count as OUR_REF, an attempt to
fetch objects at the tip of them will be rejected, and because these
refs do not get advertised, "git push :" will not see local branches
that have the same name as them as "matching" ones to be sent.
An attempt to update/delete these hidden refs with an explicit
refspec, e.g. "git push origin :refs/hidden/22", is rejected. This
is not a new restriction. To the pusher, it would appear that there
is no such ref, so its push request will conclude with "Now that I
sent you all the data, it is time for you to update the refs. I saw
that the ref did not exist when I started pushing, and I want the
result to point at this commit". The receiving end will apply the
compare-and-swap rule to this request and rejects the push with
"Well, your update request conflicts with somebody else; I see there
is such a ref.", which is the right thing to do. Otherwise a push to
a hidden ref will always be "the last one wins", which is not a good
default.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-19 00:08:30 +00:00
|
|
|
return parse_hide_refs_config(var, value, "uploadpack");
|
|
|
|
}
|
|
|
|
|
2018-03-14 18:31:41 +00:00
|
|
|
void upload_pack(struct upload_pack_options *options)
|
2005-07-04 20:26:53 +00:00
|
|
|
{
|
2018-03-14 18:31:41 +00:00
|
|
|
struct string_list symref = STRING_LIST_INIT_DUP;
|
2018-10-18 20:43:28 +00:00
|
|
|
struct object_array want_obj = OBJECT_ARRAY_INIT;
|
2018-12-29 21:19:14 +00:00
|
|
|
struct packet_reader reader;
|
2005-10-19 21:27:01 +00:00
|
|
|
|
2018-03-14 18:31:41 +00:00
|
|
|
stateless_rpc = options->stateless_rpc;
|
|
|
|
timeout = options->timeout;
|
|
|
|
daemon_mode = options->daemon_mode;
|
2009-01-18 12:00:12 +00:00
|
|
|
|
upload/receive-pack: allow hiding ref hierarchies
A repository may have refs that are only used for its internal
bookkeeping purposes that should not be exposed to the others that
come over the network.
Teach upload-pack to omit some refs from its initial advertisement
by paying attention to the uploadpack.hiderefs multi-valued
configuration variable. Do the same to receive-pack via the
receive.hiderefs variable. As a convenient short-hand, allow using
transfer.hiderefs to set the value to both of these variables.
Any ref that is under the hierarchies listed on the value of these
variable is excluded from responses to requests made by "ls-remote",
"fetch", etc. (for upload-pack) and "push" (for receive-pack).
Because these hidden refs do not count as OUR_REF, an attempt to
fetch objects at the tip of them will be rejected, and because these
refs do not get advertised, "git push :" will not see local branches
that have the same name as them as "matching" ones to be sent.
An attempt to update/delete these hidden refs with an explicit
refspec, e.g. "git push origin :refs/hidden/22", is rejected. This
is not a new restriction. To the pusher, it would appear that there
is no such ref, so its push request will conclude with "Now that I
sent you all the data, it is time for you to update the refs. I saw
that the ref did not exist when I started pushing, and I want the
result to point at this commit". The receiving end will apply the
compare-and-swap rule to this request and rejects the push with
"Well, your update request conflicts with somebody else; I see there
is such a ref.", which is the right thing to do. Otherwise a push to
a hidden ref will always be "the last one wins", which is not a good
default.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-19 00:08:30 +00:00
|
|
|
git_config(upload_pack_config, NULL);
|
2005-10-19 21:27:01 +00:00
|
|
|
|
2018-03-14 18:31:41 +00:00
|
|
|
head_ref_namespaced(find_symref, &symref);
|
2007-06-07 07:04:01 +00:00
|
|
|
|
2018-03-14 18:31:41 +00:00
|
|
|
if (options->advertise_refs || !stateless_rpc) {
|
|
|
|
reset_timeout();
|
|
|
|
head_ref_namespaced(send_ref, &symref);
|
|
|
|
for_each_namespaced_ref(send_ref, &symref);
|
|
|
|
advertise_shallow_grafts(1);
|
|
|
|
packet_flush(1);
|
|
|
|
} else {
|
|
|
|
head_ref_namespaced(check_ref, NULL);
|
|
|
|
for_each_namespaced_ref(check_ref, NULL);
|
2017-10-16 17:55:26 +00:00
|
|
|
}
|
2018-03-14 18:31:41 +00:00
|
|
|
string_list_clear(&symref, 1);
|
|
|
|
if (options->advertise_refs)
|
|
|
|
return;
|
2008-02-12 11:28:01 +00:00
|
|
|
|
pack-protocol.txt: accept error packets in any context
In the Git pack protocol definition, an error packet may appear only in
a certain context. However, servers can face a runtime error (e.g. I/O
error) at an arbitrary timing. This patch changes the protocol to allow
an error packet to be sent instead of any packet.
Without this protocol spec change, when a server cannot process a
request, there's no way to tell that to a client. Since the server
cannot produce a valid response, it would be forced to cut a connection
without telling why. With this protocol spec change, the server can be
more gentle in this situation. An old client may see these error packets
as an unexpected packet, but this is not worse than having an unexpected
EOF.
Following this protocol spec change, the error packet handling code is
moved to pkt-line.c. Implementation wise, this implementation uses
pkt-line to communicate with a subprocess. Since this is not a part of
Git protocol, it's possible that a packet that is not supposed to be an
error packet is mistakenly parsed as an error packet. This error packet
handling is enabled only for the Git pack protocol parsing code
considering this.
Signed-off-by: Masaya Suzuki <masayasuzuki@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-12-29 21:19:15 +00:00
|
|
|
packet_reader_init(&reader, 0, NULL, 0,
|
|
|
|
PACKET_READ_CHOMP_NEWLINE |
|
|
|
|
PACKET_READ_DIE_ON_ERR_PACKET);
|
2018-12-29 21:19:14 +00:00
|
|
|
|
|
|
|
receive_needs(&reader, &want_obj);
|
2018-03-14 18:31:41 +00:00
|
|
|
if (want_obj.nr) {
|
2018-10-18 20:43:27 +00:00
|
|
|
struct object_array have_obj = OBJECT_ARRAY_INIT;
|
2018-12-29 21:19:14 +00:00
|
|
|
get_common_commits(&reader, &have_obj, &want_obj);
|
2018-10-18 20:43:28 +00:00
|
|
|
create_pack_file(&have_obj, &want_obj);
|
2018-03-14 18:31:41 +00:00
|
|
|
}
|
2005-07-04 20:26:53 +00:00
|
|
|
}
|
2008-02-12 11:28:01 +00:00
|
|
|
|
2018-03-15 17:31:27 +00:00
|
|
|
struct upload_pack_data {
|
|
|
|
struct object_array wants;
|
2018-06-27 22:30:17 +00:00
|
|
|
struct string_list wanted_refs;
|
2018-03-15 17:31:27 +00:00
|
|
|
struct oid_array haves;
|
2005-07-08 23:22:22 +00:00
|
|
|
|
2018-03-15 17:31:28 +00:00
|
|
|
struct object_array shallows;
|
|
|
|
struct string_list deepen_not;
|
|
|
|
int depth;
|
|
|
|
timestamp_t deepen_since;
|
|
|
|
int deepen_rev_list;
|
|
|
|
int deepen_relative;
|
2013-12-05 13:02:32 +00:00
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
struct packet_writer writer;
|
|
|
|
|
2018-03-15 17:31:27 +00:00
|
|
|
unsigned stateless_rpc : 1;
|
2017-10-16 17:55:26 +00:00
|
|
|
|
2018-03-15 17:31:27 +00:00
|
|
|
unsigned use_thin_pack : 1;
|
|
|
|
unsigned use_ofs_delta : 1;
|
|
|
|
unsigned no_progress : 1;
|
|
|
|
unsigned use_include_tag : 1;
|
|
|
|
unsigned done : 1;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void upload_pack_data_init(struct upload_pack_data *data)
|
|
|
|
{
|
|
|
|
struct object_array wants = OBJECT_ARRAY_INIT;
|
2018-06-27 22:30:17 +00:00
|
|
|
struct string_list wanted_refs = STRING_LIST_INIT_DUP;
|
2018-03-15 17:31:27 +00:00
|
|
|
struct oid_array haves = OID_ARRAY_INIT;
|
2018-03-15 17:31:28 +00:00
|
|
|
struct object_array shallows = OBJECT_ARRAY_INIT;
|
|
|
|
struct string_list deepen_not = STRING_LIST_INIT_DUP;
|
2018-03-15 17:31:27 +00:00
|
|
|
|
|
|
|
memset(data, 0, sizeof(*data));
|
|
|
|
data->wants = wants;
|
2018-06-27 22:30:17 +00:00
|
|
|
data->wanted_refs = wanted_refs;
|
2018-03-15 17:31:27 +00:00
|
|
|
data->haves = haves;
|
2018-03-15 17:31:28 +00:00
|
|
|
data->shallows = shallows;
|
|
|
|
data->deepen_not = deepen_not;
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_init(&data->writer, 1);
|
2018-03-15 17:31:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void upload_pack_data_clear(struct upload_pack_data *data)
|
|
|
|
{
|
|
|
|
object_array_clear(&data->wants);
|
2018-06-27 22:30:17 +00:00
|
|
|
string_list_clear(&data->wanted_refs, 1);
|
2018-03-15 17:31:27 +00:00
|
|
|
oid_array_clear(&data->haves);
|
2018-03-15 17:31:28 +00:00
|
|
|
object_array_clear(&data->shallows);
|
|
|
|
string_list_clear(&data->deepen_not, 0);
|
2018-03-15 17:31:27 +00:00
|
|
|
}
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
static int parse_want(struct packet_writer *writer, const char *line,
|
|
|
|
struct object_array *want_obj)
|
2018-03-15 17:31:27 +00:00
|
|
|
{
|
|
|
|
const char *arg;
|
|
|
|
if (skip_prefix(line, "want ", &arg)) {
|
|
|
|
struct object_id oid;
|
|
|
|
struct object *o;
|
|
|
|
|
|
|
|
if (get_oid_hex(arg, &oid))
|
|
|
|
die("git upload-pack: protocol error, "
|
|
|
|
"expected to get oid, not '%s'", line);
|
|
|
|
|
2018-06-29 01:21:51 +00:00
|
|
|
o = parse_object(the_repository, &oid);
|
2018-03-15 17:31:27 +00:00
|
|
|
if (!o) {
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_error(writer,
|
|
|
|
"upload-pack: not our ref %s",
|
|
|
|
oid_to_hex(&oid));
|
2018-03-15 17:31:27 +00:00
|
|
|
die("git upload-pack: not our ref %s",
|
|
|
|
oid_to_hex(&oid));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(o->flags & WANTED)) {
|
|
|
|
o->flags |= WANTED;
|
2018-10-18 20:43:28 +00:00
|
|
|
add_object_array(o, NULL, want_obj);
|
2018-03-15 17:31:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
static int parse_want_ref(struct packet_writer *writer, const char *line,
|
|
|
|
struct string_list *wanted_refs,
|
2018-10-18 20:43:28 +00:00
|
|
|
struct object_array *want_obj)
|
2018-06-27 22:30:17 +00:00
|
|
|
{
|
|
|
|
const char *arg;
|
|
|
|
if (skip_prefix(line, "want-ref ", &arg)) {
|
|
|
|
struct object_id oid;
|
|
|
|
struct string_list_item *item;
|
|
|
|
struct object *o;
|
|
|
|
|
|
|
|
if (read_ref(arg, &oid)) {
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_error(writer, "unknown ref %s", arg);
|
2018-06-27 22:30:17 +00:00
|
|
|
die("unknown ref %s", arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
item = string_list_append(wanted_refs, arg);
|
|
|
|
item->util = oiddup(&oid);
|
|
|
|
|
|
|
|
o = parse_object_or_die(&oid, arg);
|
|
|
|
if (!(o->flags & WANTED)) {
|
|
|
|
o->flags |= WANTED;
|
2018-10-18 20:43:28 +00:00
|
|
|
add_object_array(o, NULL, want_obj);
|
2018-06-27 22:30:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-03-15 17:31:27 +00:00
|
|
|
static int parse_have(const char *line, struct oid_array *haves)
|
|
|
|
{
|
|
|
|
const char *arg;
|
|
|
|
if (skip_prefix(line, "have ", &arg)) {
|
|
|
|
struct object_id oid;
|
|
|
|
|
|
|
|
if (get_oid_hex(arg, &oid))
|
|
|
|
die("git upload-pack: expected SHA1 object, got '%s'", arg);
|
|
|
|
oid_array_append(haves, &oid);
|
|
|
|
return 1;
|
2017-10-16 17:55:26 +00:00
|
|
|
}
|
|
|
|
|
2005-07-04 20:26:53 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2018-03-15 17:31:27 +00:00
|
|
|
|
|
|
|
static void process_args(struct packet_reader *request,
|
2018-10-18 20:43:28 +00:00
|
|
|
struct upload_pack_data *data,
|
|
|
|
struct object_array *want_obj)
|
2018-03-15 17:31:27 +00:00
|
|
|
{
|
|
|
|
while (packet_reader_read(request) != PACKET_READ_FLUSH) {
|
|
|
|
const char *arg = request->line;
|
2018-05-03 23:46:56 +00:00
|
|
|
const char *p;
|
2018-03-15 17:31:27 +00:00
|
|
|
|
|
|
|
/* process want */
|
2019-01-15 19:40:27 +00:00
|
|
|
if (parse_want(&data->writer, arg, want_obj))
|
2018-03-15 17:31:27 +00:00
|
|
|
continue;
|
2018-10-18 20:43:28 +00:00
|
|
|
if (allow_ref_in_want &&
|
2019-01-15 19:40:27 +00:00
|
|
|
parse_want_ref(&data->writer, arg, &data->wanted_refs,
|
|
|
|
want_obj))
|
2018-06-27 22:30:17 +00:00
|
|
|
continue;
|
2018-03-15 17:31:27 +00:00
|
|
|
/* process have line */
|
|
|
|
if (parse_have(arg, &data->haves))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* process args like thin-pack */
|
|
|
|
if (!strcmp(arg, "thin-pack")) {
|
|
|
|
use_thin_pack = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "ofs-delta")) {
|
|
|
|
use_ofs_delta = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "no-progress")) {
|
|
|
|
no_progress = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "include-tag")) {
|
|
|
|
use_include_tag = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "done")) {
|
|
|
|
data->done = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-03-15 17:31:28 +00:00
|
|
|
/* Shallow related arguments */
|
|
|
|
if (process_shallow(arg, &data->shallows))
|
|
|
|
continue;
|
|
|
|
if (process_deepen(arg, &data->depth))
|
|
|
|
continue;
|
|
|
|
if (process_deepen_since(arg, &data->deepen_since,
|
|
|
|
&data->deepen_rev_list))
|
|
|
|
continue;
|
|
|
|
if (process_deepen_not(arg, &data->deepen_not,
|
|
|
|
&data->deepen_rev_list))
|
|
|
|
continue;
|
|
|
|
if (!strcmp(arg, "deepen-relative")) {
|
|
|
|
data->deepen_relative = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-05-03 23:46:56 +00:00
|
|
|
if (allow_filter && skip_prefix(arg, "filter ", &p)) {
|
|
|
|
parse_list_objects_filter(&filter_options, p);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-01-16 19:28:15 +00:00
|
|
|
if ((git_env_bool("GIT_TEST_SIDEBAND_ALL", 0) ||
|
|
|
|
allow_sideband_all) &&
|
|
|
|
!strcmp(arg, "sideband-all")) {
|
2019-01-16 19:28:14 +00:00
|
|
|
data->writer.use_sideband = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-03-15 17:31:27 +00:00
|
|
|
/* ignore unknown lines maybe? */
|
2018-05-02 00:31:29 +00:00
|
|
|
die("unexpected line: '%s'", arg);
|
2018-03-15 17:31:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-18 20:43:27 +00:00
|
|
|
static int process_haves(struct oid_array *haves, struct oid_array *common,
|
|
|
|
struct object_array *have_obj)
|
2018-03-15 17:31:27 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Process haves */
|
|
|
|
for (i = 0; i < haves->nr; i++) {
|
|
|
|
const struct object_id *oid = &haves->oid[i];
|
|
|
|
struct object *o;
|
|
|
|
int we_knew_they_have = 0;
|
|
|
|
|
|
|
|
if (!has_object_file(oid))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
oid_array_append(common, oid);
|
|
|
|
|
2018-06-29 01:21:51 +00:00
|
|
|
o = parse_object(the_repository, oid);
|
2018-03-15 17:31:27 +00:00
|
|
|
if (!o)
|
|
|
|
die("oops (%s)", oid_to_hex(oid));
|
|
|
|
if (o->type == OBJ_COMMIT) {
|
|
|
|
struct commit_list *parents;
|
|
|
|
struct commit *commit = (struct commit *)o;
|
|
|
|
if (o->flags & THEY_HAVE)
|
|
|
|
we_knew_they_have = 1;
|
|
|
|
else
|
|
|
|
o->flags |= THEY_HAVE;
|
|
|
|
if (!oldest_have || (commit->date < oldest_have))
|
|
|
|
oldest_have = commit->date;
|
|
|
|
for (parents = commit->parents;
|
|
|
|
parents;
|
|
|
|
parents = parents->next)
|
|
|
|
parents->item->object.flags |= THEY_HAVE;
|
|
|
|
}
|
|
|
|
if (!we_knew_they_have)
|
2018-10-18 20:43:27 +00:00
|
|
|
add_object_array(o, NULL, have_obj);
|
2018-03-15 17:31:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
static int send_acks(struct packet_writer *writer, struct oid_array *acks,
|
2018-10-18 20:43:28 +00:00
|
|
|
const struct object_array *have_obj,
|
|
|
|
struct object_array *want_obj)
|
2018-03-15 17:31:27 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_write(writer, "acknowledgments\n");
|
2018-03-15 17:31:27 +00:00
|
|
|
|
|
|
|
/* Send Acks */
|
|
|
|
if (!acks->nr)
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_write(writer, "NAK\n");
|
2018-03-15 17:31:27 +00:00
|
|
|
|
|
|
|
for (i = 0; i < acks->nr; i++) {
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_write(writer, "ACK %s\n",
|
|
|
|
oid_to_hex(&acks->oid[i]));
|
2018-03-15 17:31:27 +00:00
|
|
|
}
|
|
|
|
|
2018-10-18 20:43:28 +00:00
|
|
|
if (ok_to_give_up(have_obj, want_obj)) {
|
2018-03-15 17:31:27 +00:00
|
|
|
/* Send Ready */
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_write(writer, "ready\n");
|
2018-03-15 17:31:27 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-10-18 20:43:27 +00:00
|
|
|
static int process_haves_and_send_acks(struct upload_pack_data *data,
|
2018-10-18 20:43:28 +00:00
|
|
|
struct object_array *have_obj,
|
|
|
|
struct object_array *want_obj)
|
2018-03-15 17:31:27 +00:00
|
|
|
{
|
|
|
|
struct oid_array common = OID_ARRAY_INIT;
|
|
|
|
int ret = 0;
|
|
|
|
|
2018-10-18 20:43:27 +00:00
|
|
|
process_haves(&data->haves, &common, have_obj);
|
2018-03-15 17:31:27 +00:00
|
|
|
if (data->done) {
|
|
|
|
ret = 1;
|
2019-01-15 19:40:27 +00:00
|
|
|
} else if (send_acks(&data->writer, &common, have_obj, want_obj)) {
|
|
|
|
packet_writer_delim(&data->writer);
|
2018-03-15 17:31:27 +00:00
|
|
|
ret = 1;
|
|
|
|
} else {
|
|
|
|
/* Add Flush */
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_flush(&data->writer);
|
2018-03-15 17:31:27 +00:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
oid_array_clear(&data->haves);
|
|
|
|
oid_array_clear(&common);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-06-27 22:30:17 +00:00
|
|
|
static void send_wanted_ref_info(struct upload_pack_data *data)
|
|
|
|
{
|
|
|
|
const struct string_list_item *item;
|
|
|
|
|
|
|
|
if (!data->wanted_refs.nr)
|
|
|
|
return;
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_write(&data->writer, "wanted-refs\n");
|
2018-06-27 22:30:17 +00:00
|
|
|
|
|
|
|
for_each_string_list_item(item, &data->wanted_refs) {
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_write(&data->writer, "%s %s\n",
|
|
|
|
oid_to_hex(item->util),
|
|
|
|
item->string);
|
2018-06-27 22:30:17 +00:00
|
|
|
}
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_delim(&data->writer);
|
2018-06-27 22:30:17 +00:00
|
|
|
}
|
|
|
|
|
2018-10-18 20:43:28 +00:00
|
|
|
static void send_shallow_info(struct upload_pack_data *data,
|
|
|
|
struct object_array *want_obj)
|
2018-03-15 17:31:28 +00:00
|
|
|
{
|
|
|
|
/* No shallow info needs to be sent */
|
|
|
|
if (!data->depth && !data->deepen_rev_list && !data->shallows.nr &&
|
2018-07-18 19:20:27 +00:00
|
|
|
!is_repository_shallow(the_repository))
|
2018-03-15 17:31:28 +00:00
|
|
|
return;
|
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_write(&data->writer, "shallow-info\n");
|
2018-03-15 17:31:28 +00:00
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
if (!send_shallow_list(&data->writer, data->depth,
|
|
|
|
data->deepen_rev_list,
|
2018-03-15 17:31:28 +00:00
|
|
|
data->deepen_since, &data->deepen_not,
|
2018-12-18 21:24:35 +00:00
|
|
|
data->deepen_relative,
|
2018-10-18 20:43:28 +00:00
|
|
|
&data->shallows, want_obj) &&
|
2018-07-18 19:20:27 +00:00
|
|
|
is_repository_shallow(the_repository))
|
2019-01-15 19:40:27 +00:00
|
|
|
deepen(&data->writer, INFINITE_DEPTH, data->deepen_relative,
|
|
|
|
&data->shallows, want_obj);
|
2018-03-15 17:31:28 +00:00
|
|
|
|
|
|
|
packet_delim(1);
|
|
|
|
}
|
|
|
|
|
2018-03-15 17:31:27 +00:00
|
|
|
enum fetch_state {
|
|
|
|
FETCH_PROCESS_ARGS = 0,
|
|
|
|
FETCH_SEND_ACKS,
|
|
|
|
FETCH_SEND_PACK,
|
|
|
|
FETCH_DONE,
|
|
|
|
};
|
|
|
|
|
|
|
|
int upload_pack_v2(struct repository *r, struct argv_array *keys,
|
|
|
|
struct packet_reader *request)
|
|
|
|
{
|
|
|
|
enum fetch_state state = FETCH_PROCESS_ARGS;
|
|
|
|
struct upload_pack_data data;
|
upload-pack: clear flags before each v2 request
Suppose a server has the following commit graph:
A B
\ /
O
We create a client by cloning A from the server with depth 1, and add
many commits to it (so that future fetches span multiple requests due to
lengthy negotiation). If it then fetches B using protocol v2, the fetch
spanning multiple requests, the resulting packfile does not contain O
even though the client did report that A is shallow.
This is because upload_pack_v2() can be called multiple times while
processing the same session. During the 2nd and all subsequent
invocations, some object flags remain from the previous invocations. In
particular, CLIENT_SHALLOW remains, preventing process_shallow() from
adding client-reported shallows to the "shallows" array, and hence
pack-objects not knowing about these client-reported shallows.
Therefore, teach upload_pack_v2() to clear object flags at the start of
each invocation. This has some other results:
- THEY_HAVE gates addition of objects to have_obj in process_haves().
Previously in upload_pack_v2(), have_obj needed to be static because
once an object is added to have_obj, it is never readded and thus we
needed to retain the contents of have_obj between invocations. Now
that flags are cleared, this is no longer necessary. This patch does
not change the behavior of ok_to_give_up() (THEY_HAVE is still set on
each "have") and got_oid() (used only in non-v2)); THEY_HAVE is not
used in any other function.
- WANTED gates addition of objects to want_obj in parse_want() and
parse_want_ref(). It is also used in receive_needs(), but that is
only used in non-v2. For the same reasons as THEY_HAVE, want_obj no
longer needs to be static in upload_pack_v2().
- CLIENT_SHALLOW is changed as discussed above.
Clearing of the other 5 flags does not affect functionality in v2. (Note
that in non-v2, upload_pack() is only called once per process, so each
invocation starts with blank flags anyway.)
- OUR_REF is only used in non-v2.
- COMMON_KNOWN is only used as a scratch flag in ok_to_give_up().
- SHALLOW is passed to invocations in deepen() and
deepen_by_rev_list(), but upload-pack doesn't use it.
- NOT_SHALLOW is used by send_shallow() and send_unshallow(), but
invocations of those functions are always preceded by code that sets
NOT_SHALLOW on the appropriate objects.
- HIDDEN_REF is only used in non-v2.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-18 20:43:29 +00:00
|
|
|
struct object_array have_obj = OBJECT_ARRAY_INIT;
|
|
|
|
struct object_array want_obj = OBJECT_ARRAY_INIT;
|
|
|
|
|
|
|
|
clear_object_flags(ALL_FLAGS);
|
2018-03-15 17:31:27 +00:00
|
|
|
|
2018-05-03 23:46:55 +00:00
|
|
|
git_config(upload_pack_config, NULL);
|
|
|
|
|
2018-03-15 17:31:27 +00:00
|
|
|
upload_pack_data_init(&data);
|
|
|
|
use_sideband = LARGE_PACKET_MAX;
|
|
|
|
|
|
|
|
while (state != FETCH_DONE) {
|
|
|
|
switch (state) {
|
|
|
|
case FETCH_PROCESS_ARGS:
|
2018-10-18 20:43:28 +00:00
|
|
|
process_args(request, &data, &want_obj);
|
2018-03-15 17:31:27 +00:00
|
|
|
|
|
|
|
if (!want_obj.nr) {
|
|
|
|
/*
|
|
|
|
* Request didn't contain any 'want' lines,
|
|
|
|
* guess they didn't want anything.
|
|
|
|
*/
|
|
|
|
state = FETCH_DONE;
|
|
|
|
} else if (data.haves.nr) {
|
|
|
|
/*
|
|
|
|
* Request had 'have' lines, so lets ACK them.
|
|
|
|
*/
|
|
|
|
state = FETCH_SEND_ACKS;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Request had 'want's but no 'have's so we can
|
|
|
|
* immedietly go to construct and send a pack.
|
|
|
|
*/
|
|
|
|
state = FETCH_SEND_PACK;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case FETCH_SEND_ACKS:
|
2018-10-18 20:43:28 +00:00
|
|
|
if (process_haves_and_send_acks(&data, &have_obj,
|
|
|
|
&want_obj))
|
2018-03-15 17:31:27 +00:00
|
|
|
state = FETCH_SEND_PACK;
|
|
|
|
else
|
|
|
|
state = FETCH_DONE;
|
|
|
|
break;
|
|
|
|
case FETCH_SEND_PACK:
|
2018-06-27 22:30:17 +00:00
|
|
|
send_wanted_ref_info(&data);
|
2018-10-18 20:43:28 +00:00
|
|
|
send_shallow_info(&data, &want_obj);
|
2018-03-15 17:31:28 +00:00
|
|
|
|
2019-01-15 19:40:27 +00:00
|
|
|
packet_writer_write(&data.writer, "packfile\n");
|
2018-10-18 20:43:28 +00:00
|
|
|
create_pack_file(&have_obj, &want_obj);
|
2018-03-15 17:31:27 +00:00
|
|
|
state = FETCH_DONE;
|
|
|
|
break;
|
|
|
|
case FETCH_DONE:
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
upload_pack_data_clear(&data);
|
upload-pack: clear flags before each v2 request
Suppose a server has the following commit graph:
A B
\ /
O
We create a client by cloning A from the server with depth 1, and add
many commits to it (so that future fetches span multiple requests due to
lengthy negotiation). If it then fetches B using protocol v2, the fetch
spanning multiple requests, the resulting packfile does not contain O
even though the client did report that A is shallow.
This is because upload_pack_v2() can be called multiple times while
processing the same session. During the 2nd and all subsequent
invocations, some object flags remain from the previous invocations. In
particular, CLIENT_SHALLOW remains, preventing process_shallow() from
adding client-reported shallows to the "shallows" array, and hence
pack-objects not knowing about these client-reported shallows.
Therefore, teach upload_pack_v2() to clear object flags at the start of
each invocation. This has some other results:
- THEY_HAVE gates addition of objects to have_obj in process_haves().
Previously in upload_pack_v2(), have_obj needed to be static because
once an object is added to have_obj, it is never readded and thus we
needed to retain the contents of have_obj between invocations. Now
that flags are cleared, this is no longer necessary. This patch does
not change the behavior of ok_to_give_up() (THEY_HAVE is still set on
each "have") and got_oid() (used only in non-v2)); THEY_HAVE is not
used in any other function.
- WANTED gates addition of objects to want_obj in parse_want() and
parse_want_ref(). It is also used in receive_needs(), but that is
only used in non-v2. For the same reasons as THEY_HAVE, want_obj no
longer needs to be static in upload_pack_v2().
- CLIENT_SHALLOW is changed as discussed above.
Clearing of the other 5 flags does not affect functionality in v2. (Note
that in non-v2, upload_pack() is only called once per process, so each
invocation starts with blank flags anyway.)
- OUR_REF is only used in non-v2.
- COMMON_KNOWN is only used as a scratch flag in ok_to_give_up().
- SHALLOW is passed to invocations in deepen() and
deepen_by_rev_list(), but upload-pack doesn't use it.
- NOT_SHALLOW is used by send_shallow() and send_unshallow(), but
invocations of those functions are always preceded by code that sets
NOT_SHALLOW on the appropriate objects.
- HIDDEN_REF is only used in non-v2.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-18 20:43:29 +00:00
|
|
|
object_array_clear(&have_obj);
|
|
|
|
object_array_clear(&want_obj);
|
2018-03-15 17:31:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2018-03-15 17:31:28 +00:00
|
|
|
|
|
|
|
int upload_pack_advertise(struct repository *r,
|
|
|
|
struct strbuf *value)
|
|
|
|
{
|
2018-05-03 23:46:56 +00:00
|
|
|
if (value) {
|
|
|
|
int allow_filter_value;
|
2018-06-27 22:30:17 +00:00
|
|
|
int allow_ref_in_want;
|
2019-01-16 19:28:14 +00:00
|
|
|
int allow_sideband_all_value;
|
2018-06-27 22:30:17 +00:00
|
|
|
|
2018-03-15 17:31:28 +00:00
|
|
|
strbuf_addstr(value, "shallow");
|
2018-06-27 22:30:17 +00:00
|
|
|
|
2018-05-03 23:46:56 +00:00
|
|
|
if (!repo_config_get_bool(the_repository,
|
|
|
|
"uploadpack.allowfilter",
|
|
|
|
&allow_filter_value) &&
|
|
|
|
allow_filter_value)
|
|
|
|
strbuf_addstr(value, " filter");
|
2018-06-27 22:30:17 +00:00
|
|
|
|
|
|
|
if (!repo_config_get_bool(the_repository,
|
|
|
|
"uploadpack.allowrefinwant",
|
|
|
|
&allow_ref_in_want) &&
|
|
|
|
allow_ref_in_want)
|
|
|
|
strbuf_addstr(value, " ref-in-want");
|
2019-01-16 19:28:14 +00:00
|
|
|
|
2019-01-16 19:28:15 +00:00
|
|
|
if (git_env_bool("GIT_TEST_SIDEBAND_ALL", 0) ||
|
|
|
|
(!repo_config_get_bool(the_repository,
|
|
|
|
"uploadpack.allowsidebandall",
|
|
|
|
&allow_sideband_all_value) &&
|
|
|
|
allow_sideband_all_value))
|
2019-01-16 19:28:14 +00:00
|
|
|
strbuf_addstr(value, " sideband-all");
|
2018-05-03 23:46:56 +00:00
|
|
|
}
|
2018-06-27 22:30:17 +00:00
|
|
|
|
2018-03-15 17:31:28 +00:00
|
|
|
return 1;
|
|
|
|
}
|