2011-04-03 07:06:54 +00:00
|
|
|
#include "builtin.h"
|
2006-11-01 22:06:21 +00:00
|
|
|
#include "pack.h"
|
2005-07-03 03:23:36 +00:00
|
|
|
#include "refs.h"
|
2005-06-30 03:50:15 +00:00
|
|
|
#include "pkt-line.h"
|
2010-02-05 20:57:41 +00:00
|
|
|
#include "sideband.h"
|
2005-07-31 19:17:43 +00:00
|
|
|
#include "run-command.h"
|
2006-11-01 22:06:25 +00:00
|
|
|
#include "exec_cmd.h"
|
2006-09-20 23:07:54 +00:00
|
|
|
#include "commit.h"
|
|
|
|
#include "object.h"
|
push: receiver end advertises refs from alternate repositories
Earlier, when pushing into a repository that borrows from alternate object
stores, we followed the longstanding design decision not to trust refs in
the alternate repository that houses the object store we are borrowing
from. If your public repository is borrowing from Linus's public
repository, you pushed into it long time ago, and now when you try to push
your updated history that is in sync with more recent history from Linus,
you will end up sending not just your own development, but also the
changes you acquired through Linus's tree, even though the objects needed
for the latter already exists at the receiving end. This is because the
receiving end does not advertise that the objects only reachable from the
borrowed repository (i.e. Linus's) are already available there.
This solves the issue by making the receiving end advertise refs from
borrowed repositories. They are not sent with their true names but with a
phoney name ".have" to make sure that the old senders will safely ignore
them (otherwise, the old senders will misbehave, trying to push matching
refs, and mirror push that deletes refs that only exist at the receiving
end).
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-09 08:27:10 +00:00
|
|
|
#include "remote.h"
|
|
|
|
#include "transport.h"
|
2010-04-19 22:19:18 +00:00
|
|
|
#include "string-list.h"
|
receive-pack: eliminate duplicate .have refs
When receiving a push, we advertise ref tips from any
alternate repositories, in case that helps the client send a
smaller pack. Since these refs don't actually exist in the
destination repository, we don't transmit the real ref
names, but instead use the pseudo-ref ".have".
If your alternate has a large number of duplicate refs (for
example, because it is aggregating objects from many related
repositories, some of which will have the same tags and
branch tips), then we will send each ".have $sha1" line
multiple times. This is a pointless waste of bandwidth, as
we are simply repeating the same fact to the client over and
over.
This patch eliminates duplicate .have refs early on. It does
so efficiently by sorting the complete list and skipping
duplicates. This has the side effect of re-ordering the
.have lines by ascending sha1; this isn't a problem, though,
as the original order was meaningless.
There is a similar .have system in fetch-pack, but it
does not suffer from the same problem. For each alternate
ref we consider in fetch-pack, we actually open the object
and mark it with the SEEN flag, so duplicates are
automatically culled.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-19 21:34:46 +00:00
|
|
|
#include "sha1-array.h"
|
2005-06-30 00:52:11 +00:00
|
|
|
|
2009-01-04 18:39:27 +00:00
|
|
|
static const char receive_pack_usage[] = "git receive-pack <git-dir>";
|
2005-06-30 00:52:11 +00:00
|
|
|
|
2008-11-09 01:49:27 +00:00
|
|
|
enum deny_action {
|
2009-02-01 01:34:05 +00:00
|
|
|
DENY_UNCONFIGURED,
|
2008-11-09 01:49:27 +00:00
|
|
|
DENY_IGNORE,
|
|
|
|
DENY_WARN,
|
2010-05-14 09:31:35 +00:00
|
|
|
DENY_REFUSE
|
2008-11-09 01:49:27 +00:00
|
|
|
};
|
|
|
|
|
2009-02-09 06:19:43 +00:00
|
|
|
static int deny_deletes;
|
|
|
|
static int deny_non_fast_forwards;
|
2009-02-01 01:34:05 +00:00
|
|
|
static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
|
2009-02-09 06:31:21 +00:00
|
|
|
static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
|
2008-02-25 21:46:13 +00:00
|
|
|
static int receive_fsck_objects;
|
2007-01-25 01:02:15 +00:00
|
|
|
static int receive_unpack_limit = -1;
|
|
|
|
static int transfer_unpack_limit = -1;
|
2006-12-07 04:01:00 +00:00
|
|
|
static int unpack_limit = 100;
|
2006-08-15 17:23:48 +00:00
|
|
|
static int report_status;
|
2010-02-05 20:57:41 +00:00
|
|
|
static int use_sideband;
|
2009-05-01 20:56:47 +00:00
|
|
|
static int prefer_ofs_delta = 1;
|
2009-10-20 21:56:40 +00:00
|
|
|
static int auto_update_server_info;
|
|
|
|
static int auto_gc = 1;
|
2009-02-09 06:31:21 +00:00
|
|
|
static const char *head_name;
|
2010-02-05 20:57:40 +00:00
|
|
|
static int sent_capabilities;
|
2005-12-26 07:18:37 +00:00
|
|
|
|
2008-11-09 01:49:27 +00:00
|
|
|
static enum deny_action parse_deny_action(const char *var, const char *value)
|
|
|
|
{
|
|
|
|
if (value) {
|
|
|
|
if (!strcasecmp(value, "ignore"))
|
|
|
|
return DENY_IGNORE;
|
|
|
|
if (!strcasecmp(value, "warn"))
|
|
|
|
return DENY_WARN;
|
|
|
|
if (!strcasecmp(value, "refuse"))
|
|
|
|
return DENY_REFUSE;
|
|
|
|
}
|
|
|
|
if (git_config_bool(var, value))
|
|
|
|
return DENY_REFUSE;
|
|
|
|
return DENY_IGNORE;
|
|
|
|
}
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int receive_pack_config(const char *var, const char *value, void *cb)
|
2006-10-30 22:35:18 +00:00
|
|
|
{
|
2008-11-01 14:42:16 +00:00
|
|
|
if (strcmp(var, "receive.denydeletes") == 0) {
|
|
|
|
deny_deletes = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-25 01:02:15 +00:00
|
|
|
if (strcmp(var, "receive.denynonfastforwards") == 0) {
|
2006-10-30 22:35:18 +00:00
|
|
|
deny_non_fast_forwards = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-25 01:02:15 +00:00
|
|
|
if (strcmp(var, "receive.unpacklimit") == 0) {
|
|
|
|
receive_unpack_limit = git_config_int(var, value);
|
2006-11-01 22:06:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-25 01:02:15 +00:00
|
|
|
if (strcmp(var, "transfer.unpacklimit") == 0) {
|
|
|
|
transfer_unpack_limit = git_config_int(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-25 21:46:13 +00:00
|
|
|
if (strcmp(var, "receive.fsckobjects") == 0) {
|
|
|
|
receive_fsck_objects = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-09 01:49:27 +00:00
|
|
|
if (!strcmp(var, "receive.denycurrentbranch")) {
|
|
|
|
deny_current_branch = parse_deny_action(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-09 06:31:21 +00:00
|
|
|
if (strcmp(var, "receive.denydeletecurrent") == 0) {
|
|
|
|
deny_delete_current = parse_deny_action(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-01 20:56:47 +00:00
|
|
|
if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
|
|
|
|
prefer_ofs_delta = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-20 21:56:40 +00:00
|
|
|
if (strcmp(var, "receive.updateserverinfo") == 0) {
|
|
|
|
auto_update_server_info = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(var, "receive.autogc") == 0) {
|
|
|
|
auto_gc = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
return git_default_config(var, value, cb);
|
2006-10-30 22:35:18 +00:00
|
|
|
}
|
|
|
|
|
2006-09-21 05:02:01 +00:00
|
|
|
static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
2005-06-30 00:52:11 +00:00
|
|
|
{
|
2010-02-05 20:57:40 +00:00
|
|
|
if (sent_capabilities)
|
2005-12-26 07:18:37 +00:00
|
|
|
packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
|
|
|
|
else
|
2010-02-05 20:57:40 +00:00
|
|
|
packet_write(1, "%s %s%c%s%s\n",
|
|
|
|
sha1_to_hex(sha1), path, 0,
|
2010-02-05 20:57:41 +00:00
|
|
|
" report-status delete-refs side-band-64k",
|
2010-02-05 20:57:40 +00:00
|
|
|
prefer_ofs_delta ? " ofs-delta" : "");
|
|
|
|
sent_capabilities = 1;
|
2005-07-03 03:23:36 +00:00
|
|
|
return 0;
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
|
|
|
|
2005-07-03 03:23:36 +00:00
|
|
|
static void write_head_info(void)
|
2005-06-30 00:52:11 +00:00
|
|
|
{
|
2006-09-21 04:47:42 +00:00
|
|
|
for_each_ref(show_ref, NULL);
|
2010-02-05 20:57:40 +00:00
|
|
|
if (!sent_capabilities)
|
2006-09-21 05:02:01 +00:00
|
|
|
show_ref("capabilities^{}", null_sha1, 0, NULL);
|
2005-12-26 07:18:37 +00:00
|
|
|
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
|
|
|
|
2005-06-30 06:01:14 +00:00
|
|
|
struct command {
|
|
|
|
struct command *next;
|
2005-12-26 07:18:37 +00:00
|
|
|
const char *error_string;
|
2010-04-19 22:19:18 +00:00
|
|
|
unsigned int skip_update;
|
2005-06-30 06:01:14 +00:00
|
|
|
unsigned char old_sha1[20];
|
|
|
|
unsigned char new_sha1[20];
|
2006-01-07 09:33:54 +00:00
|
|
|
char ref_name[FLEX_ARRAY]; /* more */
|
2005-06-30 00:52:11 +00:00
|
|
|
};
|
|
|
|
|
2007-03-07 21:52:05 +00:00
|
|
|
static const char pre_receive_hook[] = "hooks/pre-receive";
|
|
|
|
static const char post_receive_hook[] = "hooks/post-receive";
|
2005-07-31 19:17:43 +00:00
|
|
|
|
2010-02-10 17:34:12 +00:00
|
|
|
static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
|
|
|
|
static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
|
|
|
|
|
|
|
|
static void report_message(const char *prefix, const char *err, va_list params)
|
|
|
|
{
|
|
|
|
int sz = strlen(prefix);
|
|
|
|
char msg[4096];
|
|
|
|
|
|
|
|
strncpy(msg, prefix, sz);
|
|
|
|
sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
|
|
|
|
if (sz > (sizeof(msg) - 1))
|
|
|
|
sz = sizeof(msg) - 1;
|
|
|
|
msg[sz++] = '\n';
|
|
|
|
|
|
|
|
if (use_sideband)
|
|
|
|
send_sideband(1, 2, msg, sz, use_sideband);
|
|
|
|
else
|
|
|
|
xwrite(2, msg, sz);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rp_warning(const char *err, ...)
|
|
|
|
{
|
|
|
|
va_list params;
|
|
|
|
va_start(params, err);
|
|
|
|
report_message("warning: ", err, params);
|
|
|
|
va_end(params);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rp_error(const char *err, ...)
|
|
|
|
{
|
|
|
|
va_list params;
|
|
|
|
va_start(params, err);
|
|
|
|
report_message("error: ", err, params);
|
|
|
|
va_end(params);
|
|
|
|
}
|
|
|
|
|
2010-02-05 20:57:42 +00:00
|
|
|
static int copy_to_sideband(int in, int out, void *arg)
|
|
|
|
{
|
|
|
|
char data[128];
|
|
|
|
while (1) {
|
|
|
|
ssize_t sz = xread(in, data, sizeof(data));
|
|
|
|
if (sz <= 0)
|
|
|
|
break;
|
|
|
|
send_sideband(1, 2, data, sz, use_sideband);
|
|
|
|
}
|
|
|
|
close(in);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
static int run_receive_hook(struct command *commands, const char *hook_name)
|
2005-07-31 19:17:43 +00:00
|
|
|
{
|
2007-03-10 08:28:16 +00:00
|
|
|
static char buf[sizeof(commands->old_sha1) * 2 + PATH_MAX + 4];
|
2007-03-07 21:51:09 +00:00
|
|
|
struct command *cmd;
|
2007-03-10 08:28:16 +00:00
|
|
|
struct child_process proc;
|
2010-02-05 20:57:42 +00:00
|
|
|
struct async muxer;
|
2007-03-10 08:28:16 +00:00
|
|
|
const char *argv[2];
|
|
|
|
int have_input = 0, code;
|
2007-03-07 21:51:09 +00:00
|
|
|
|
2007-03-10 08:28:16 +00:00
|
|
|
for (cmd = commands; !have_input && cmd; cmd = cmd->next) {
|
2007-03-07 21:51:09 +00:00
|
|
|
if (!cmd->error_string)
|
2007-03-10 08:28:16 +00:00
|
|
|
have_input = 1;
|
2007-03-07 21:51:09 +00:00
|
|
|
}
|
2005-07-31 19:17:43 +00:00
|
|
|
|
2007-03-10 08:28:16 +00:00
|
|
|
if (!have_input || access(hook_name, X_OK) < 0)
|
2005-07-31 19:17:43 +00:00
|
|
|
return 0;
|
2007-03-07 21:51:09 +00:00
|
|
|
|
|
|
|
argv[0] = hook_name;
|
2007-03-10 08:28:16 +00:00
|
|
|
argv[1] = NULL;
|
|
|
|
|
|
|
|
memset(&proc, 0, sizeof(proc));
|
|
|
|
proc.argv = argv;
|
|
|
|
proc.in = -1;
|
|
|
|
proc.stdout_to_stderr = 1;
|
|
|
|
|
2010-02-05 20:57:42 +00:00
|
|
|
if (use_sideband) {
|
|
|
|
memset(&muxer, 0, sizeof(muxer));
|
|
|
|
muxer.proc = copy_to_sideband;
|
|
|
|
muxer.in = -1;
|
|
|
|
code = start_async(&muxer);
|
|
|
|
if (code)
|
|
|
|
return code;
|
|
|
|
proc.err = muxer.in;
|
|
|
|
}
|
|
|
|
|
2007-03-10 08:28:16 +00:00
|
|
|
code = start_command(&proc);
|
2010-02-05 20:57:42 +00:00
|
|
|
if (code) {
|
|
|
|
if (use_sideband)
|
|
|
|
finish_async(&muxer);
|
2009-07-04 19:26:43 +00:00
|
|
|
return code;
|
2010-02-05 20:57:42 +00:00
|
|
|
}
|
|
|
|
|
2007-03-10 08:28:16 +00:00
|
|
|
for (cmd = commands; cmd; cmd = cmd->next) {
|
2007-03-07 21:51:09 +00:00
|
|
|
if (!cmd->error_string) {
|
2007-03-10 08:28:16 +00:00
|
|
|
size_t n = snprintf(buf, sizeof(buf), "%s %s %s\n",
|
|
|
|
sha1_to_hex(cmd->old_sha1),
|
|
|
|
sha1_to_hex(cmd->new_sha1),
|
|
|
|
cmd->ref_name);
|
|
|
|
if (write_in_full(proc.in, buf, n) != n)
|
|
|
|
break;
|
2007-03-07 21:51:09 +00:00
|
|
|
}
|
|
|
|
}
|
2008-02-16 17:36:38 +00:00
|
|
|
close(proc.in);
|
2010-02-05 20:57:42 +00:00
|
|
|
if (use_sideband)
|
|
|
|
finish_async(&muxer);
|
2009-07-04 19:26:43 +00:00
|
|
|
return finish_command(&proc);
|
2005-07-31 19:17:43 +00:00
|
|
|
}
|
|
|
|
|
2007-03-10 08:28:13 +00:00
|
|
|
static int run_update_hook(struct command *cmd)
|
|
|
|
{
|
|
|
|
static const char update_hook[] = "hooks/update";
|
|
|
|
const char *argv[5];
|
2010-02-05 20:57:42 +00:00
|
|
|
struct child_process proc;
|
|
|
|
int code;
|
2007-03-10 08:28:13 +00:00
|
|
|
|
|
|
|
if (access(update_hook, X_OK) < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
argv[0] = update_hook;
|
|
|
|
argv[1] = cmd->ref_name;
|
|
|
|
argv[2] = sha1_to_hex(cmd->old_sha1);
|
|
|
|
argv[3] = sha1_to_hex(cmd->new_sha1);
|
|
|
|
argv[4] = NULL;
|
|
|
|
|
2010-02-05 20:57:42 +00:00
|
|
|
memset(&proc, 0, sizeof(proc));
|
|
|
|
proc.no_stdin = 1;
|
|
|
|
proc.stdout_to_stderr = 1;
|
|
|
|
proc.err = use_sideband ? -1 : 0;
|
|
|
|
proc.argv = argv;
|
|
|
|
|
|
|
|
code = start_command(&proc);
|
|
|
|
if (code)
|
|
|
|
return code;
|
|
|
|
if (use_sideband)
|
|
|
|
copy_to_sideband(proc.err, -1, NULL);
|
|
|
|
return finish_command(&proc);
|
2007-03-10 08:28:13 +00:00
|
|
|
}
|
|
|
|
|
2008-11-09 01:49:27 +00:00
|
|
|
static int is_ref_checked_out(const char *ref)
|
|
|
|
{
|
|
|
|
if (is_bare_repository())
|
|
|
|
return 0;
|
|
|
|
|
2009-02-09 06:31:21 +00:00
|
|
|
if (!head_name)
|
2008-11-09 01:49:27 +00:00
|
|
|
return 0;
|
2009-02-09 06:31:21 +00:00
|
|
|
return !strcmp(head_name, ref);
|
2008-11-09 01:49:27 +00:00
|
|
|
}
|
|
|
|
|
2009-02-11 10:28:03 +00:00
|
|
|
static char *refuse_unconfigured_deny_msg[] = {
|
|
|
|
"By default, updating the current branch in a non-bare repository",
|
|
|
|
"is denied, because it will make the index and work tree inconsistent",
|
|
|
|
"with what you pushed, and will require 'git reset --hard' to match",
|
|
|
|
"the work tree to HEAD.",
|
2009-02-01 01:34:05 +00:00
|
|
|
"",
|
|
|
|
"You can set 'receive.denyCurrentBranch' configuration variable to",
|
2009-02-11 10:28:03 +00:00
|
|
|
"'ignore' or 'warn' in the remote repository to allow pushing into",
|
|
|
|
"its current branch; however, this is not recommended unless you",
|
|
|
|
"arranged to update its work tree to match what you pushed in some",
|
|
|
|
"other way.",
|
2009-02-01 01:34:05 +00:00
|
|
|
"",
|
2009-02-11 10:28:03 +00:00
|
|
|
"To squelch this message and still keep the default behaviour, set",
|
|
|
|
"'receive.denyCurrentBranch' configuration variable to 'refuse'."
|
2009-02-01 01:34:05 +00:00
|
|
|
};
|
|
|
|
|
2009-02-11 10:28:03 +00:00
|
|
|
static void refuse_unconfigured_deny(void)
|
2009-02-01 01:34:05 +00:00
|
|
|
{
|
|
|
|
int i;
|
2009-02-11 10:28:03 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
|
2010-03-03 06:54:50 +00:00
|
|
|
rp_error("%s", refuse_unconfigured_deny_msg[i]);
|
2009-02-01 01:34:05 +00:00
|
|
|
}
|
|
|
|
|
2009-02-09 08:19:46 +00:00
|
|
|
static char *refuse_unconfigured_deny_delete_current_msg[] = {
|
|
|
|
"By default, deleting the current branch is denied, because the next",
|
|
|
|
"'git clone' won't result in any file checked out, causing confusion.",
|
2009-02-09 06:31:21 +00:00
|
|
|
"",
|
|
|
|
"You can set 'receive.denyDeleteCurrent' configuration variable to",
|
2009-02-09 08:19:46 +00:00
|
|
|
"'warn' or 'ignore' in the remote repository to allow deleting the",
|
|
|
|
"current branch, with or without a warning message.",
|
2009-02-09 06:31:21 +00:00
|
|
|
"",
|
2009-02-09 08:19:46 +00:00
|
|
|
"To squelch this message, you can set it to 'refuse'."
|
2009-02-09 06:31:21 +00:00
|
|
|
};
|
|
|
|
|
2009-02-09 08:19:46 +00:00
|
|
|
static void refuse_unconfigured_deny_delete_current(void)
|
2009-02-09 06:31:21 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0;
|
2009-02-09 08:19:46 +00:00
|
|
|
i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
|
2009-02-09 06:31:21 +00:00
|
|
|
i++)
|
2010-03-03 06:54:50 +00:00
|
|
|
rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
|
2009-02-09 06:31:21 +00:00
|
|
|
}
|
|
|
|
|
2007-03-07 21:51:59 +00:00
|
|
|
static const char *update(struct command *cmd)
|
2005-06-30 17:15:22 +00:00
|
|
|
{
|
2005-12-26 07:18:37 +00:00
|
|
|
const char *name = cmd->ref_name;
|
|
|
|
unsigned char *old_sha1 = cmd->old_sha1;
|
|
|
|
unsigned char *new_sha1 = cmd->new_sha1;
|
2006-09-27 09:40:06 +00:00
|
|
|
struct ref_lock *lock;
|
2005-06-30 17:15:22 +00:00
|
|
|
|
2008-01-04 19:37:17 +00:00
|
|
|
/* only refs/... are allowed */
|
|
|
|
if (prefixcmp(name, "refs/") || check_ref_format(name + 5)) {
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_error("refusing to create funny ref '%s' remotely", name);
|
2007-03-07 21:51:59 +00:00
|
|
|
return "funny refname";
|
2005-12-26 07:18:37 +00:00
|
|
|
}
|
2005-10-14 01:57:39 +00:00
|
|
|
|
2009-02-01 01:34:05 +00:00
|
|
|
if (is_ref_checked_out(name)) {
|
|
|
|
switch (deny_current_branch) {
|
|
|
|
case DENY_IGNORE:
|
2008-11-09 01:49:27 +00:00
|
|
|
break;
|
2009-02-01 01:34:05 +00:00
|
|
|
case DENY_WARN:
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_warning("updating the current branch");
|
2008-11-09 01:49:27 +00:00
|
|
|
break;
|
2009-02-01 01:34:05 +00:00
|
|
|
case DENY_REFUSE:
|
2009-02-11 10:28:03 +00:00
|
|
|
case DENY_UNCONFIGURED:
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_error("refusing to update checked out branch: %s", name);
|
2009-02-11 10:28:03 +00:00
|
|
|
if (deny_current_branch == DENY_UNCONFIGURED)
|
|
|
|
refuse_unconfigured_deny();
|
2009-02-01 01:34:05 +00:00
|
|
|
return "branch is currently checked out";
|
|
|
|
}
|
2008-11-09 01:49:27 +00:00
|
|
|
}
|
|
|
|
|
2006-11-24 08:26:49 +00:00
|
|
|
if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
|
2007-03-07 21:51:59 +00:00
|
|
|
error("unpack should have generated %s, "
|
|
|
|
"but I can't find it!", sha1_to_hex(new_sha1));
|
|
|
|
return "bad pack";
|
2005-12-26 07:18:37 +00:00
|
|
|
}
|
2009-02-09 06:31:21 +00:00
|
|
|
|
|
|
|
if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
|
|
|
|
if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_error("denying ref deletion for %s", name);
|
2009-02-09 06:31:21 +00:00
|
|
|
return "deletion prohibited";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(name, head_name)) {
|
|
|
|
switch (deny_delete_current) {
|
|
|
|
case DENY_IGNORE:
|
|
|
|
break;
|
|
|
|
case DENY_WARN:
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_warning("deleting the current branch");
|
2009-02-09 06:31:21 +00:00
|
|
|
break;
|
|
|
|
case DENY_REFUSE:
|
2009-02-09 08:19:46 +00:00
|
|
|
case DENY_UNCONFIGURED:
|
|
|
|
if (deny_delete_current == DENY_UNCONFIGURED)
|
|
|
|
refuse_unconfigured_deny_delete_current();
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_error("refusing to delete the current branch: %s", name);
|
2009-02-09 06:31:21 +00:00
|
|
|
return "deletion of the current branch prohibited";
|
|
|
|
}
|
|
|
|
}
|
2008-11-01 14:42:16 +00:00
|
|
|
}
|
2009-02-09 06:31:21 +00:00
|
|
|
|
2006-11-24 08:26:49 +00:00
|
|
|
if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
|
2006-12-05 00:30:00 +00:00
|
|
|
!is_null_sha1(old_sha1) &&
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
!prefixcmp(name, "refs/heads/")) {
|
2008-01-02 07:39:21 +00:00
|
|
|
struct object *old_object, *new_object;
|
2006-09-20 23:07:54 +00:00
|
|
|
struct commit *old_commit, *new_commit;
|
2006-09-21 00:07:19 +00:00
|
|
|
struct commit_list *bases, *ent;
|
2006-09-20 23:07:54 +00:00
|
|
|
|
2008-01-02 07:39:21 +00:00
|
|
|
old_object = parse_object(old_sha1);
|
|
|
|
new_object = parse_object(new_sha1);
|
|
|
|
|
|
|
|
if (!old_object || !new_object ||
|
|
|
|
old_object->type != OBJ_COMMIT ||
|
|
|
|
new_object->type != OBJ_COMMIT) {
|
|
|
|
error("bad sha1 objects for %s", name);
|
|
|
|
return "bad ref";
|
|
|
|
}
|
|
|
|
old_commit = (struct commit *)old_object;
|
|
|
|
new_commit = (struct commit *)new_object;
|
2006-09-21 00:07:19 +00:00
|
|
|
bases = get_merge_bases(old_commit, new_commit, 1);
|
|
|
|
for (ent = bases; ent; ent = ent->next)
|
|
|
|
if (!hashcmp(old_sha1, ent->item->object.sha1))
|
2006-09-20 23:07:54 +00:00
|
|
|
break;
|
2006-09-21 00:07:19 +00:00
|
|
|
free_commit_list(bases);
|
2007-03-07 21:51:59 +00:00
|
|
|
if (!ent) {
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_error("denying non-fast-forward %s"
|
|
|
|
" (you should pull first)", name);
|
2009-10-24 08:31:32 +00:00
|
|
|
return "non-fast-forward";
|
2007-03-07 21:51:59 +00:00
|
|
|
}
|
2006-09-20 23:07:54 +00:00
|
|
|
}
|
2007-03-10 08:28:13 +00:00
|
|
|
if (run_update_hook(cmd)) {
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_error("hook declined to update %s", name);
|
2007-03-07 21:51:59 +00:00
|
|
|
return "hook declined";
|
2005-07-31 19:17:43 +00:00
|
|
|
}
|
2006-09-27 09:40:06 +00:00
|
|
|
|
2006-11-24 08:26:49 +00:00
|
|
|
if (is_null_sha1(new_sha1)) {
|
2007-11-29 01:02:53 +00:00
|
|
|
if (!parse_object(old_sha1)) {
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_warning("Allowing deletion of corrupt ref.");
|
2007-11-29 01:02:53 +00:00
|
|
|
old_sha1 = NULL;
|
|
|
|
}
|
2008-10-26 02:33:56 +00:00
|
|
|
if (delete_ref(name, old_sha1, 0)) {
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_error("failed to delete %s", name);
|
2007-03-07 21:51:59 +00:00
|
|
|
return "failed to delete";
|
2006-11-24 08:26:49 +00:00
|
|
|
}
|
2007-03-07 21:51:59 +00:00
|
|
|
return NULL; /* good */
|
2006-11-24 08:26:49 +00:00
|
|
|
}
|
|
|
|
else {
|
2007-05-09 10:33:20 +00:00
|
|
|
lock = lock_any_ref_for_update(name, old_sha1, 0);
|
2006-11-24 08:26:49 +00:00
|
|
|
if (!lock) {
|
2010-02-10 17:34:12 +00:00
|
|
|
rp_error("failed to lock %s", name);
|
2007-03-07 21:51:59 +00:00
|
|
|
return "failed to lock";
|
2006-11-24 08:26:49 +00:00
|
|
|
}
|
2007-03-07 17:04:24 +00:00
|
|
|
if (write_ref_sha1(lock, new_sha1, "push")) {
|
2007-03-07 21:51:59 +00:00
|
|
|
return "failed to write"; /* error() already called */
|
2007-03-07 17:04:24 +00:00
|
|
|
}
|
2007-03-07 21:51:59 +00:00
|
|
|
return NULL; /* good */
|
2005-08-02 21:24:22 +00:00
|
|
|
}
|
2005-06-30 17:15:22 +00:00
|
|
|
}
|
|
|
|
|
2005-08-02 21:24:22 +00:00
|
|
|
static char update_post_hook[] = "hooks/post-update";
|
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
static void run_update_post_hook(struct command *commands)
|
2005-08-02 21:24:22 +00:00
|
|
|
{
|
2010-04-19 22:08:30 +00:00
|
|
|
struct command *cmd;
|
2010-02-05 20:57:42 +00:00
|
|
|
int argc;
|
2006-03-05 10:47:29 +00:00
|
|
|
const char **argv;
|
2010-02-05 20:57:42 +00:00
|
|
|
struct child_process proc;
|
2005-08-02 21:24:22 +00:00
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
|
|
|
|
if (cmd->error_string)
|
2005-08-02 21:24:22 +00:00
|
|
|
continue;
|
|
|
|
argc++;
|
|
|
|
}
|
2007-03-07 21:50:43 +00:00
|
|
|
if (!argc || access(update_post_hook, X_OK) < 0)
|
|
|
|
return;
|
|
|
|
argv = xmalloc(sizeof(*argv) * (2 + argc));
|
2005-08-02 21:24:22 +00:00
|
|
|
argv[0] = update_post_hook;
|
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
|
2006-03-05 10:47:29 +00:00
|
|
|
char *p;
|
2010-04-19 22:08:30 +00:00
|
|
|
if (cmd->error_string)
|
2005-08-02 21:24:22 +00:00
|
|
|
continue;
|
2010-04-19 22:08:30 +00:00
|
|
|
p = xmalloc(strlen(cmd->ref_name) + 1);
|
|
|
|
strcpy(p, cmd->ref_name);
|
2006-03-05 10:47:29 +00:00
|
|
|
argv[argc] = p;
|
2005-08-02 21:24:22 +00:00
|
|
|
argc++;
|
|
|
|
}
|
|
|
|
argv[argc] = NULL;
|
2010-02-05 20:57:42 +00:00
|
|
|
|
|
|
|
memset(&proc, 0, sizeof(proc));
|
|
|
|
proc.no_stdin = 1;
|
|
|
|
proc.stdout_to_stderr = 1;
|
|
|
|
proc.err = use_sideband ? -1 : 0;
|
|
|
|
proc.argv = argv;
|
|
|
|
|
|
|
|
if (!start_command(&proc)) {
|
|
|
|
if (use_sideband)
|
|
|
|
copy_to_sideband(proc.err, -1, NULL);
|
|
|
|
finish_command(&proc);
|
|
|
|
}
|
2005-08-02 21:24:22 +00:00
|
|
|
}
|
2005-06-30 17:15:22 +00:00
|
|
|
|
2010-04-19 22:19:18 +00:00
|
|
|
static void check_aliased_update(struct command *cmd, struct string_list *list)
|
|
|
|
{
|
|
|
|
struct string_list_item *item;
|
|
|
|
struct command *dst_cmd;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
|
|
|
|
int flag;
|
|
|
|
|
|
|
|
const char *dst_name = resolve_ref(cmd->ref_name, sha1, 0, &flag);
|
|
|
|
|
|
|
|
if (!(flag & REF_ISSYMREF))
|
|
|
|
return;
|
|
|
|
|
2010-06-25 23:41:37 +00:00
|
|
|
if ((item = string_list_lookup(list, dst_name)) == NULL)
|
2010-04-19 22:19:18 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
cmd->skip_update = 1;
|
|
|
|
|
|
|
|
dst_cmd = (struct command *) item->util;
|
|
|
|
|
|
|
|
if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
|
|
|
|
!hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
|
|
|
|
return;
|
|
|
|
|
|
|
|
dst_cmd->skip_update = 1;
|
|
|
|
|
|
|
|
strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
|
2010-06-10 18:43:51 +00:00
|
|
|
strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
|
2010-04-19 22:19:18 +00:00
|
|
|
strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
|
2010-06-10 18:43:51 +00:00
|
|
|
strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
|
2010-04-19 22:19:18 +00:00
|
|
|
rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
|
|
|
|
" its target '%s' (%s..%s)",
|
|
|
|
cmd->ref_name, cmd_oldh, cmd_newh,
|
|
|
|
dst_cmd->ref_name, dst_oldh, dst_newh);
|
|
|
|
|
|
|
|
cmd->error_string = dst_cmd->error_string =
|
|
|
|
"inconsistent aliased update";
|
|
|
|
}
|
|
|
|
|
|
|
|
static void check_aliased_updates(struct command *commands)
|
|
|
|
{
|
|
|
|
struct command *cmd;
|
2010-07-04 19:46:19 +00:00
|
|
|
struct string_list ref_list = STRING_LIST_INIT_NODUP;
|
2010-04-19 22:19:18 +00:00
|
|
|
|
|
|
|
for (cmd = commands; cmd; cmd = cmd->next) {
|
|
|
|
struct string_list_item *item =
|
2010-06-25 23:41:38 +00:00
|
|
|
string_list_append(&ref_list, cmd->ref_name);
|
2010-04-19 22:19:18 +00:00
|
|
|
item->util = (void *)cmd;
|
|
|
|
}
|
|
|
|
sort_string_list(&ref_list);
|
|
|
|
|
|
|
|
for (cmd = commands; cmd; cmd = cmd->next)
|
|
|
|
check_aliased_update(cmd, &ref_list);
|
|
|
|
|
|
|
|
string_list_clear(&ref_list, 0);
|
|
|
|
}
|
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
static void execute_commands(struct command *commands, const char *unpacker_error)
|
2005-06-30 00:52:11 +00:00
|
|
|
{
|
2010-04-19 22:08:30 +00:00
|
|
|
struct command *cmd;
|
2009-02-09 06:31:21 +00:00
|
|
|
unsigned char sha1[20];
|
2007-03-07 21:51:59 +00:00
|
|
|
|
|
|
|
if (unpacker_error) {
|
2010-04-19 22:08:30 +00:00
|
|
|
for (cmd = commands; cmd; cmd = cmd->next)
|
2007-03-07 21:51:59 +00:00
|
|
|
cmd->error_string = "n/a (unpacker error)";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
if (run_receive_hook(commands, pre_receive_hook)) {
|
|
|
|
for (cmd = commands; cmd; cmd = cmd->next)
|
2007-03-07 21:52:05 +00:00
|
|
|
cmd->error_string = "pre-receive hook declined";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-04-19 22:19:18 +00:00
|
|
|
check_aliased_updates(commands);
|
|
|
|
|
2009-02-09 06:31:21 +00:00
|
|
|
head_name = resolve_ref("HEAD", sha1, 0, NULL);
|
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
for (cmd = commands; cmd; cmd = cmd->next)
|
2010-04-19 22:19:18 +00:00
|
|
|
if (!cmd->skip_update)
|
|
|
|
cmd->error_string = update(cmd);
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
static struct command *read_head_info(void)
|
2005-06-30 00:52:11 +00:00
|
|
|
{
|
2010-04-19 22:08:30 +00:00
|
|
|
struct command *commands = NULL;
|
2005-06-30 06:01:14 +00:00
|
|
|
struct command **p = &commands;
|
2005-06-30 00:52:11 +00:00
|
|
|
for (;;) {
|
|
|
|
static char line[1000];
|
2005-06-30 06:01:14 +00:00
|
|
|
unsigned char old_sha1[20], new_sha1[20];
|
|
|
|
struct command *cmd;
|
2005-12-26 07:18:37 +00:00
|
|
|
char *refname;
|
|
|
|
int len, reflen;
|
2005-06-30 06:01:14 +00:00
|
|
|
|
|
|
|
len = packet_read_line(0, line, sizeof(line));
|
2005-06-30 00:52:11 +00:00
|
|
|
if (!len)
|
|
|
|
break;
|
2005-06-30 06:01:14 +00:00
|
|
|
if (line[len-1] == '\n')
|
|
|
|
line[--len] = 0;
|
|
|
|
if (len < 83 ||
|
|
|
|
line[40] != ' ' ||
|
|
|
|
line[81] != ' ' ||
|
|
|
|
get_sha1_hex(line, old_sha1) ||
|
|
|
|
get_sha1_hex(line + 41, new_sha1))
|
2005-12-26 07:18:37 +00:00
|
|
|
die("protocol error: expected old/new/ref, got '%s'",
|
|
|
|
line);
|
|
|
|
|
|
|
|
refname = line + 82;
|
|
|
|
reflen = strlen(refname);
|
|
|
|
if (reflen + 82 < len) {
|
|
|
|
if (strstr(refname + reflen + 1, "report-status"))
|
|
|
|
report_status = 1;
|
2010-02-05 20:57:41 +00:00
|
|
|
if (strstr(refname + reflen + 1, "side-band-64k"))
|
|
|
|
use_sideband = LARGE_PACKET_MAX;
|
2005-12-26 07:18:37 +00:00
|
|
|
}
|
2010-04-19 22:19:18 +00:00
|
|
|
cmd = xcalloc(1, sizeof(struct command) + len - 80);
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(cmd->old_sha1, old_sha1);
|
|
|
|
hashcpy(cmd->new_sha1, new_sha1);
|
2005-06-30 06:01:14 +00:00
|
|
|
memcpy(cmd->ref_name, line + 82, len - 81);
|
|
|
|
*p = cmd;
|
|
|
|
p = &cmd->next;
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
2010-04-19 22:08:30 +00:00
|
|
|
return commands;
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
|
|
|
|
2006-11-01 22:06:21 +00:00
|
|
|
static const char *parse_pack_header(struct pack_header *hdr)
|
|
|
|
{
|
2007-01-23 05:55:18 +00:00
|
|
|
switch (read_pack_header(0, hdr)) {
|
|
|
|
case PH_ERROR_EOF:
|
|
|
|
return "eof before pack header was fully read";
|
|
|
|
|
|
|
|
case PH_ERROR_PACK_SIGNATURE:
|
2006-11-01 22:06:21 +00:00
|
|
|
return "protocol error (pack signature mismatch detected)";
|
2007-01-23 05:55:18 +00:00
|
|
|
|
|
|
|
case PH_ERROR_PROTOCOL:
|
2006-11-01 22:06:21 +00:00
|
|
|
return "protocol error (pack version unsupported)";
|
2007-01-23 05:55:18 +00:00
|
|
|
|
|
|
|
default:
|
|
|
|
return "unknown error in parse_pack_header";
|
|
|
|
|
|
|
|
case 0:
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-11-01 22:06:21 +00:00
|
|
|
}
|
|
|
|
|
2006-11-01 22:06:25 +00:00
|
|
|
static const char *pack_lockfile;
|
|
|
|
|
2011-07-30 12:10:14 +00:00
|
|
|
static const char *unpack(int quiet)
|
2005-06-30 00:52:11 +00:00
|
|
|
{
|
2006-11-01 22:06:21 +00:00
|
|
|
struct pack_header hdr;
|
|
|
|
const char *hdr_err;
|
|
|
|
char hdr_arg[38];
|
|
|
|
|
|
|
|
hdr_err = parse_pack_header(&hdr);
|
|
|
|
if (hdr_err)
|
|
|
|
return hdr_err;
|
2008-07-03 15:52:09 +00:00
|
|
|
snprintf(hdr_arg, sizeof(hdr_arg),
|
|
|
|
"--pack_header=%"PRIu32",%"PRIu32,
|
2006-11-01 22:06:21 +00:00
|
|
|
ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
|
|
|
|
|
|
|
|
if (ntohl(hdr.hdr_entries) < unpack_limit) {
|
2008-02-25 21:46:13 +00:00
|
|
|
int code, i = 0;
|
|
|
|
const char *unpacker[4];
|
|
|
|
unpacker[i++] = "unpack-objects";
|
2011-07-30 12:10:14 +00:00
|
|
|
if (quiet)
|
|
|
|
unpacker[i++] = "-q";
|
2008-02-25 21:46:13 +00:00
|
|
|
if (receive_fsck_objects)
|
|
|
|
unpacker[i++] = "--strict";
|
|
|
|
unpacker[i++] = hdr_arg;
|
|
|
|
unpacker[i++] = NULL;
|
2006-12-31 02:55:15 +00:00
|
|
|
code = run_command_v_opt(unpacker, RUN_GIT_CMD);
|
2009-06-21 21:16:09 +00:00
|
|
|
if (!code)
|
2006-11-01 22:06:21 +00:00
|
|
|
return NULL;
|
2009-06-21 21:16:09 +00:00
|
|
|
return "unpack-objects abnormal exit";
|
2006-11-01 22:06:25 +00:00
|
|
|
} else {
|
2008-02-25 21:46:13 +00:00
|
|
|
const char *keeper[7];
|
|
|
|
int s, status, i = 0;
|
2006-11-01 22:06:25 +00:00
|
|
|
char keep_arg[256];
|
2007-03-12 23:00:26 +00:00
|
|
|
struct child_process ip;
|
2006-11-01 22:06:25 +00:00
|
|
|
|
2008-08-31 12:09:39 +00:00
|
|
|
s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
|
2006-11-01 22:06:25 +00:00
|
|
|
if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
|
|
|
|
strcpy(keep_arg + s, "localhost");
|
|
|
|
|
2008-02-25 21:46:13 +00:00
|
|
|
keeper[i++] = "index-pack";
|
|
|
|
keeper[i++] = "--stdin";
|
|
|
|
if (receive_fsck_objects)
|
|
|
|
keeper[i++] = "--strict";
|
|
|
|
keeper[i++] = "--fix-thin";
|
|
|
|
keeper[i++] = hdr_arg;
|
|
|
|
keeper[i++] = keep_arg;
|
|
|
|
keeper[i++] = NULL;
|
2007-03-12 23:00:26 +00:00
|
|
|
memset(&ip, 0, sizeof(ip));
|
|
|
|
ip.argv = keeper;
|
|
|
|
ip.out = -1;
|
|
|
|
ip.git_cmd = 1;
|
2009-06-21 21:16:09 +00:00
|
|
|
status = start_command(&ip);
|
|
|
|
if (status) {
|
2006-11-01 22:06:25 +00:00
|
|
|
return "index-pack fork failed";
|
2009-06-21 21:16:09 +00:00
|
|
|
}
|
2007-09-14 07:31:16 +00:00
|
|
|
pack_lockfile = index_pack_lockfile(ip.out);
|
2008-02-16 17:36:38 +00:00
|
|
|
close(ip.out);
|
2007-03-12 23:00:26 +00:00
|
|
|
status = finish_command(&ip);
|
|
|
|
if (!status) {
|
2006-11-01 22:06:25 +00:00
|
|
|
reprepare_packed_git();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return "index-pack abnormal exit";
|
2005-12-26 07:18:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
static void report(struct command *commands, const char *unpack_status)
|
2005-12-26 07:18:37 +00:00
|
|
|
{
|
|
|
|
struct command *cmd;
|
2010-02-05 20:57:41 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
packet_buf_write(&buf, "unpack %s\n",
|
|
|
|
unpack_status ? unpack_status : "ok");
|
2005-12-26 07:18:37 +00:00
|
|
|
for (cmd = commands; cmd; cmd = cmd->next) {
|
|
|
|
if (!cmd->error_string)
|
2010-02-05 20:57:41 +00:00
|
|
|
packet_buf_write(&buf, "ok %s\n",
|
|
|
|
cmd->ref_name);
|
2005-12-26 07:18:37 +00:00
|
|
|
else
|
2010-02-05 20:57:41 +00:00
|
|
|
packet_buf_write(&buf, "ng %s %s\n",
|
|
|
|
cmd->ref_name, cmd->error_string);
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
2010-02-05 20:57:41 +00:00
|
|
|
packet_buf_flush(&buf);
|
|
|
|
|
|
|
|
if (use_sideband)
|
|
|
|
send_sideband(1, 1, buf.buf, buf.len, use_sideband);
|
|
|
|
else
|
|
|
|
safe_write(1, buf.buf, buf.len);
|
|
|
|
strbuf_release(&buf);
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
static int delete_only(struct command *commands)
|
2006-11-24 08:26:49 +00:00
|
|
|
{
|
2010-04-19 22:08:30 +00:00
|
|
|
struct command *cmd;
|
|
|
|
for (cmd = commands; cmd; cmd = cmd->next) {
|
2006-11-24 08:26:49 +00:00
|
|
|
if (!is_null_sha1(cmd->new_sha1))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
receive-pack: eliminate duplicate .have refs
When receiving a push, we advertise ref tips from any
alternate repositories, in case that helps the client send a
smaller pack. Since these refs don't actually exist in the
destination repository, we don't transmit the real ref
names, but instead use the pseudo-ref ".have".
If your alternate has a large number of duplicate refs (for
example, because it is aggregating objects from many related
repositories, some of which will have the same tags and
branch tips), then we will send each ".have $sha1" line
multiple times. This is a pointless waste of bandwidth, as
we are simply repeating the same fact to the client over and
over.
This patch eliminates duplicate .have refs early on. It does
so efficiently by sorting the complete list and skipping
duplicates. This has the side effect of re-ordering the
.have lines by ascending sha1; this isn't a problem, though,
as the original order was meaningless.
There is a similar .have system in fetch-pack, but it
does not suffer from the same problem. For each alternate
ref we consider in fetch-pack, we actually open the object
and mark it with the SEEN flag, so duplicates are
automatically culled.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-19 21:34:46 +00:00
|
|
|
static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
|
push: receiver end advertises refs from alternate repositories
Earlier, when pushing into a repository that borrows from alternate object
stores, we followed the longstanding design decision not to trust refs in
the alternate repository that houses the object store we are borrowing
from. If your public repository is borrowing from Linus's public
repository, you pushed into it long time ago, and now when you try to push
your updated history that is in sync with more recent history from Linus,
you will end up sending not just your own development, but also the
changes you acquired through Linus's tree, even though the objects needed
for the latter already exists at the receiving end. This is because the
receiving end does not advertise that the objects only reachable from the
borrowed repository (i.e. Linus's) are already available there.
This solves the issue by making the receiving end advertise refs from
borrowed repositories. They are not sent with their true names but with a
phoney name ".have" to make sure that the old senders will safely ignore
them (otherwise, the old senders will misbehave, trying to push matching
refs, and mirror push that deletes refs that only exist at the receiving
end).
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-09 08:27:10 +00:00
|
|
|
{
|
receive-pack: eliminate duplicate .have refs
When receiving a push, we advertise ref tips from any
alternate repositories, in case that helps the client send a
smaller pack. Since these refs don't actually exist in the
destination repository, we don't transmit the real ref
names, but instead use the pseudo-ref ".have".
If your alternate has a large number of duplicate refs (for
example, because it is aggregating objects from many related
repositories, some of which will have the same tags and
branch tips), then we will send each ".have $sha1" line
multiple times. This is a pointless waste of bandwidth, as
we are simply repeating the same fact to the client over and
over.
This patch eliminates duplicate .have refs early on. It does
so efficiently by sorting the complete list and skipping
duplicates. This has the side effect of re-ordering the
.have lines by ascending sha1; this isn't a problem, though,
as the original order was meaningless.
There is a similar .have system in fetch-pack, but it
does not suffer from the same problem. For each alternate
ref we consider in fetch-pack, we actually open the object
and mark it with the SEEN flag, so duplicates are
automatically culled.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-19 21:34:46 +00:00
|
|
|
add_extra_ref(".have", sha1, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void collect_one_alternate_ref(const struct ref *ref, void *data)
|
|
|
|
{
|
|
|
|
struct sha1_array *sa = data;
|
|
|
|
sha1_array_append(sa, ref->old_sha1);
|
push: receiver end advertises refs from alternate repositories
Earlier, when pushing into a repository that borrows from alternate object
stores, we followed the longstanding design decision not to trust refs in
the alternate repository that houses the object store we are borrowing
from. If your public repository is borrowing from Linus's public
repository, you pushed into it long time ago, and now when you try to push
your updated history that is in sync with more recent history from Linus,
you will end up sending not just your own development, but also the
changes you acquired through Linus's tree, even though the objects needed
for the latter already exists at the receiving end. This is because the
receiving end does not advertise that the objects only reachable from the
borrowed repository (i.e. Linus's) are already available there.
This solves the issue by making the receiving end advertise refs from
borrowed repositories. They are not sent with their true names but with a
phoney name ".have" to make sure that the old senders will safely ignore
them (otherwise, the old senders will misbehave, trying to push matching
refs, and mirror push that deletes refs that only exist at the receiving
end).
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-09 08:27:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void add_alternate_refs(void)
|
|
|
|
{
|
receive-pack: eliminate duplicate .have refs
When receiving a push, we advertise ref tips from any
alternate repositories, in case that helps the client send a
smaller pack. Since these refs don't actually exist in the
destination repository, we don't transmit the real ref
names, but instead use the pseudo-ref ".have".
If your alternate has a large number of duplicate refs (for
example, because it is aggregating objects from many related
repositories, some of which will have the same tags and
branch tips), then we will send each ".have $sha1" line
multiple times. This is a pointless waste of bandwidth, as
we are simply repeating the same fact to the client over and
over.
This patch eliminates duplicate .have refs early on. It does
so efficiently by sorting the complete list and skipping
duplicates. This has the side effect of re-ordering the
.have lines by ascending sha1; this isn't a problem, though,
as the original order was meaningless.
There is a similar .have system in fetch-pack, but it
does not suffer from the same problem. For each alternate
ref we consider in fetch-pack, we actually open the object
and mark it with the SEEN flag, so duplicates are
automatically culled.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-19 21:34:46 +00:00
|
|
|
struct sha1_array sa = SHA1_ARRAY_INIT;
|
|
|
|
for_each_alternate_ref(collect_one_alternate_ref, &sa);
|
|
|
|
sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
|
|
|
|
sha1_array_clear(&sa);
|
push: receiver end advertises refs from alternate repositories
Earlier, when pushing into a repository that borrows from alternate object
stores, we followed the longstanding design decision not to trust refs in
the alternate repository that houses the object store we are borrowing
from. If your public repository is borrowing from Linus's public
repository, you pushed into it long time ago, and now when you try to push
your updated history that is in sync with more recent history from Linus,
you will end up sending not just your own development, but also the
changes you acquired through Linus's tree, even though the objects needed
for the latter already exists at the receiving end. This is because the
receiving end does not advertise that the objects only reachable from the
borrowed repository (i.e. Linus's) are already available there.
This solves the issue by making the receiving end advertise refs from
borrowed repositories. They are not sent with their true names but with a
phoney name ".have" to make sure that the old senders will safely ignore
them (otherwise, the old senders will misbehave, trying to push matching
refs, and mirror push that deletes refs that only exist at the receiving
end).
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-09 08:27:10 +00:00
|
|
|
}
|
|
|
|
|
2008-09-09 08:27:08 +00:00
|
|
|
int cmd_receive_pack(int argc, const char **argv, const char *prefix)
|
2005-06-30 00:52:11 +00:00
|
|
|
{
|
2011-07-30 12:10:14 +00:00
|
|
|
int quiet = 0;
|
2009-10-31 00:47:33 +00:00
|
|
|
int advertise_refs = 0;
|
|
|
|
int stateless_rpc = 0;
|
2005-06-30 19:28:24 +00:00
|
|
|
int i;
|
2005-11-17 19:37:14 +00:00
|
|
|
char *dir = NULL;
|
2010-04-19 22:08:30 +00:00
|
|
|
struct command *commands;
|
2005-06-30 00:52:11 +00:00
|
|
|
|
2011-02-24 14:30:19 +00:00
|
|
|
packet_trace_identity("receive-pack");
|
|
|
|
|
2005-06-30 00:52:11 +00:00
|
|
|
argv++;
|
|
|
|
for (i = 1; i < argc; i++) {
|
2008-09-09 08:27:08 +00:00
|
|
|
const char *arg = *argv++;
|
2005-06-30 00:52:11 +00:00
|
|
|
|
|
|
|
if (*arg == '-') {
|
2011-07-30 12:10:14 +00:00
|
|
|
if (!strcmp(arg, "--quiet")) {
|
|
|
|
quiet = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2009-10-31 00:47:33 +00:00
|
|
|
if (!strcmp(arg, "--advertise-refs")) {
|
|
|
|
advertise_refs = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "--stateless-rpc")) {
|
|
|
|
stateless_rpc = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-06-30 00:52:11 +00:00
|
|
|
usage(receive_pack_usage);
|
|
|
|
}
|
2005-06-30 19:28:24 +00:00
|
|
|
if (dir)
|
|
|
|
usage(receive_pack_usage);
|
2008-09-09 08:27:08 +00:00
|
|
|
dir = xstrdup(arg);
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
|
|
|
if (!dir)
|
|
|
|
usage(receive_pack_usage);
|
|
|
|
|
2008-07-21 19:19:52 +00:00
|
|
|
setup_path();
|
2008-03-03 04:08:43 +00:00
|
|
|
|
2006-09-27 09:40:06 +00:00
|
|
|
if (!enter_repo(dir, 0))
|
2009-03-04 08:32:29 +00:00
|
|
|
die("'%s' does not appear to be a git repository", dir);
|
2005-06-30 00:52:11 +00:00
|
|
|
|
2007-01-22 06:23:58 +00:00
|
|
|
if (is_repository_shallow())
|
|
|
|
die("attempt to push into a shallow repository");
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(receive_pack_config, NULL);
|
2006-10-30 22:35:18 +00:00
|
|
|
|
2007-01-25 01:02:15 +00:00
|
|
|
if (0 <= transfer_unpack_limit)
|
|
|
|
unpack_limit = transfer_unpack_limit;
|
|
|
|
else if (0 <= receive_unpack_limit)
|
|
|
|
unpack_limit = receive_unpack_limit;
|
|
|
|
|
2009-10-31 00:47:33 +00:00
|
|
|
if (advertise_refs || !stateless_rpc) {
|
|
|
|
add_alternate_refs();
|
|
|
|
write_head_info();
|
|
|
|
clear_extra_refs();
|
2005-06-30 00:52:11 +00:00
|
|
|
|
2009-10-31 00:47:33 +00:00
|
|
|
/* EOF */
|
|
|
|
packet_flush(1);
|
|
|
|
}
|
|
|
|
if (advertise_refs)
|
|
|
|
return 0;
|
2005-06-30 00:52:11 +00:00
|
|
|
|
2010-04-19 22:08:30 +00:00
|
|
|
if ((commands = read_head_info()) != NULL) {
|
2006-11-24 08:26:49 +00:00
|
|
|
const char *unpack_status = NULL;
|
|
|
|
|
|
|
|
if (!delete_only(commands))
|
2011-07-30 12:10:14 +00:00
|
|
|
unpack_status = unpack(quiet);
|
2010-04-19 22:08:30 +00:00
|
|
|
execute_commands(commands, unpack_status);
|
2006-11-01 22:06:25 +00:00
|
|
|
if (pack_lockfile)
|
2009-04-29 21:22:56 +00:00
|
|
|
unlink_or_warn(pack_lockfile);
|
2005-12-26 07:18:37 +00:00
|
|
|
if (report_status)
|
2010-04-19 22:08:30 +00:00
|
|
|
report(commands, unpack_status);
|
|
|
|
run_receive_hook(commands, post_receive_hook);
|
2007-03-07 21:50:24 +00:00
|
|
|
run_update_post_hook(commands);
|
2009-10-20 21:56:40 +00:00
|
|
|
if (auto_gc) {
|
|
|
|
const char *argv_gc_auto[] = {
|
|
|
|
"gc", "--auto", "--quiet", NULL,
|
|
|
|
};
|
|
|
|
run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
|
|
|
|
}
|
|
|
|
if (auto_update_server_info)
|
|
|
|
update_server_info(0);
|
2005-06-30 05:50:48 +00:00
|
|
|
}
|
2010-02-05 20:57:41 +00:00
|
|
|
if (use_sideband)
|
|
|
|
packet_flush(1);
|
2005-06-30 00:52:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|