2005-06-30 00:52:11 +00:00
|
|
|
#include "cache.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"
|
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"
|
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,
|
|
|
|
DENY_REFUSE,
|
|
|
|
};
|
|
|
|
|
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;
|
2009-05-01 20:56:47 +00:00
|
|
|
static int prefer_ofs_delta = 1;
|
2009-02-09 06:31:21 +00:00
|
|
|
static const char *head_name;
|
2009-05-01 20:56:47 +00:00
|
|
|
static char *capabilities_to_send;
|
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;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2009-05-01 20:56:47 +00:00
|
|
|
if (!capabilities_to_send)
|
2005-12-26 07:18:37 +00:00
|
|
|
packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
|
|
|
|
else
|
|
|
|
packet_write(1, "%s %s%c%s\n",
|
2009-05-01 20:56:47 +00:00
|
|
|
sha1_to_hex(sha1), path, 0, capabilities_to_send);
|
|
|
|
capabilities_to_send = NULL;
|
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);
|
2009-05-01 20:56:47 +00:00
|
|
|
if (capabilities_to_send)
|
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;
|
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
|
|
|
};
|
|
|
|
|
2006-08-15 17:23:48 +00:00
|
|
|
static struct command *commands;
|
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
|
|
|
|
2009-06-21 21:16:09 +00:00
|
|
|
static int run_status(int code, const char *cmd_name)
|
2007-03-10 08:28:11 +00:00
|
|
|
{
|
run_command: report system call errors instead of returning error codes
The motivation for this change is that system call failures are serious
errors that should be reported to the user, but only few callers took the
burden to decode the error codes that the functions returned into error
messages.
If at all, then only an unspecific error message was given. A prominent
example is this:
$ git upload-pack . | :
fatal: unable to run 'git-upload-pack'
In this example, git-upload-pack, the external command invoked through the
git wrapper, dies due to SIGPIPE, but the git wrapper does not bother to
report the real cause. In fact, this very error message is copied to the
syslog if git-daemon's client aborts the connection early.
With this change, system call failures are reported immediately after the
failure and only a generic failure code is returned to the caller. In the
above example the error is now to the point:
$ git upload-pack . | :
error: git-upload-pack died of signal
Note that there is no error report if the invoked program terminated with
a non-zero exit code, because it is reasonable to expect that the invoked
program has already reported an error. (But many run_command call sites
nevertheless write a generic error message.)
There was one special return code that was used to identify the case where
run_command failed because the requested program could not be exec'd. This
special case is now treated like a system call failure with errno set to
ENOENT. No error is reported in this case, because the call site in git.c
expects this as a normal result. Therefore, the callers that carefully
decoded the return value still check for this condition.
Signed-off-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-04 19:26:40 +00:00
|
|
|
if (code < 0 && errno == ENOENT)
|
2009-06-21 21:16:09 +00:00
|
|
|
return error("execute of %s failed", cmd_name);
|
run_command: report system call errors instead of returning error codes
The motivation for this change is that system call failures are serious
errors that should be reported to the user, but only few callers took the
burden to decode the error codes that the functions returned into error
messages.
If at all, then only an unspecific error message was given. A prominent
example is this:
$ git upload-pack . | :
fatal: unable to run 'git-upload-pack'
In this example, git-upload-pack, the external command invoked through the
git wrapper, dies due to SIGPIPE, but the git wrapper does not bother to
report the real cause. In fact, this very error message is copied to the
syslog if git-daemon's client aborts the connection early.
With this change, system call failures are reported immediately after the
failure and only a generic failure code is returned to the caller. In the
above example the error is now to the point:
$ git upload-pack . | :
error: git-upload-pack died of signal
Note that there is no error report if the invoked program terminated with
a non-zero exit code, because it is reasonable to expect that the invoked
program has already reported an error. (But many run_command call sites
nevertheless write a generic error message.)
There was one special return code that was used to identify the case where
run_command failed because the requested program could not be exec'd. This
special case is now treated like a system call failure with errno set to
ENOENT. No error is reported in this case, because the call site in git.c
expects this as a normal result. Therefore, the callers that carefully
decoded the return value still check for this condition.
Signed-off-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-04 19:26:40 +00:00
|
|
|
else if (code > 0)
|
2009-07-04 19:26:39 +00:00
|
|
|
error("%s exited with error code %d", cmd_name, code);
|
run_command: report system call errors instead of returning error codes
The motivation for this change is that system call failures are serious
errors that should be reported to the user, but only few callers took the
burden to decode the error codes that the functions returned into error
messages.
If at all, then only an unspecific error message was given. A prominent
example is this:
$ git upload-pack . | :
fatal: unable to run 'git-upload-pack'
In this example, git-upload-pack, the external command invoked through the
git wrapper, dies due to SIGPIPE, but the git wrapper does not bother to
report the real cause. In fact, this very error message is copied to the
syslog if git-daemon's client aborts the connection early.
With this change, system call failures are reported immediately after the
failure and only a generic failure code is returned to the caller. In the
above example the error is now to the point:
$ git upload-pack . | :
error: git-upload-pack died of signal
Note that there is no error report if the invoked program terminated with
a non-zero exit code, because it is reasonable to expect that the invoked
program has already reported an error. (But many run_command call sites
nevertheless write a generic error message.)
There was one special return code that was used to identify the case where
run_command failed because the requested program could not be exec'd. This
special case is now treated like a system call failure with errno set to
ENOENT. No error is reported in this case, because the call site in git.c
expects this as a normal result. Therefore, the callers that carefully
decoded the return value still check for this condition.
Signed-off-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-04 19:26:40 +00:00
|
|
|
return code;
|
2007-03-10 08:28:11 +00:00
|
|
|
}
|
|
|
|
|
2009-01-16 19:09:59 +00:00
|
|
|
static int run_receive_hook(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;
|
|
|
|
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;
|
|
|
|
|
|
|
|
code = start_command(&proc);
|
|
|
|
if (code)
|
2009-06-21 21:16:09 +00:00
|
|
|
return run_status(code, hook_name);
|
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);
|
2009-06-21 21:16:09 +00:00
|
|
|
return run_status(finish_command(&proc), hook_name);
|
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];
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2009-06-21 21:16:09 +00:00
|
|
|
return run_status(run_command_v_opt(argv, RUN_COMMAND_NO_STDIN |
|
2009-06-08 20:34:29 +00:00
|
|
|
RUN_COMMAND_STDOUT_TO_STDERR),
|
|
|
|
update_hook);
|
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-01 01:34:05 +00:00
|
|
|
static char *warn_unconfigured_deny_msg[] = {
|
|
|
|
"Updating the currently checked out branch may cause confusion,",
|
|
|
|
"as the index and work tree do not reflect changes that are in HEAD.",
|
|
|
|
"As a result, you may see the changes you just pushed into it",
|
|
|
|
"reverted when you run 'git diff' over there, and you may want",
|
|
|
|
"to run 'git reset --hard' before starting to work to recover.",
|
|
|
|
"",
|
|
|
|
"You can set 'receive.denyCurrentBranch' configuration variable to",
|
|
|
|
"'refuse' in the remote repository to forbid pushing into its",
|
|
|
|
"current branch."
|
|
|
|
"",
|
|
|
|
"To allow pushing into the current branch, you can set it to 'ignore';",
|
|
|
|
"but this is not recommended unless you arranged to update its work",
|
|
|
|
"tree to match what you pushed in some other way.",
|
|
|
|
"",
|
|
|
|
"To squelch this message, you can set it to 'warn'.",
|
|
|
|
"",
|
|
|
|
"Note that the default will change in a future version of git",
|
|
|
|
"to refuse updating the current branch unless you have the",
|
|
|
|
"configuration variable set to either 'ignore' or 'warn'."
|
|
|
|
};
|
|
|
|
|
|
|
|
static void warn_unconfigured_deny(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(warn_unconfigured_deny_msg); i++)
|
2009-02-15 18:18:58 +00:00
|
|
|
warning("%s", warn_unconfigured_deny_msg[i]);
|
2009-02-01 01:34:05 +00:00
|
|
|
}
|
|
|
|
|
2009-02-09 06:31:21 +00:00
|
|
|
static char *warn_unconfigured_deny_delete_current_msg[] = {
|
|
|
|
"Deleting the current branch can cause confusion by making the next",
|
|
|
|
"'git clone' not check out any file.",
|
|
|
|
"",
|
|
|
|
"You can set 'receive.denyDeleteCurrent' configuration variable to",
|
|
|
|
"'refuse' in the remote repository to disallow deleting the current",
|
|
|
|
"branch.",
|
|
|
|
"",
|
|
|
|
"You can set it to 'ignore' to allow such a delete without a warning.",
|
|
|
|
"",
|
|
|
|
"To make this warning message less loud, you can set it to 'warn'.",
|
|
|
|
"",
|
|
|
|
"Note that the default will change in a future version of git",
|
|
|
|
"to refuse deleting the current branch unless you have the",
|
|
|
|
"configuration variable set to either 'ignore' or 'warn'."
|
|
|
|
};
|
|
|
|
|
|
|
|
static void warn_unconfigured_deny_delete_current(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0;
|
|
|
|
i < ARRAY_SIZE(warn_unconfigured_deny_delete_current_msg);
|
|
|
|
i++)
|
2009-02-15 18:18:58 +00:00
|
|
|
warning("%s", warn_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)) {
|
2007-10-20 19:31:46 +00:00
|
|
|
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_UNCONFIGURED:
|
|
|
|
case DENY_WARN:
|
|
|
|
warning("updating the current branch");
|
|
|
|
if (deny_current_branch == DENY_UNCONFIGURED)
|
|
|
|
warn_unconfigured_deny();
|
2008-11-09 01:49:27 +00:00
|
|
|
break;
|
2009-02-01 01:34:05 +00:00
|
|
|
case DENY_REFUSE:
|
|
|
|
error("refusing to update checked out branch: %s", name);
|
|
|
|
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/")) {
|
|
|
|
error("denying ref deletion for %s", name);
|
|
|
|
return "deletion prohibited";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(name, head_name)) {
|
|
|
|
switch (deny_delete_current) {
|
|
|
|
case DENY_IGNORE:
|
|
|
|
break;
|
|
|
|
case DENY_WARN:
|
|
|
|
case DENY_UNCONFIGURED:
|
|
|
|
if (deny_delete_current == DENY_UNCONFIGURED)
|
|
|
|
warn_unconfigured_deny_delete_current();
|
|
|
|
warning("deleting the current branch");
|
|
|
|
break;
|
|
|
|
case DENY_REFUSE:
|
|
|
|
error("refusing to delete the current branch: %s", name);
|
|
|
|
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) {
|
|
|
|
error("denying non-fast forward %s"
|
|
|
|
" (you should pull first)", name);
|
|
|
|
return "non-fast forward";
|
|
|
|
}
|
2006-09-20 23:07:54 +00:00
|
|
|
}
|
2007-03-10 08:28:13 +00:00
|
|
|
if (run_update_hook(cmd)) {
|
2007-03-07 21:51:59 +00:00
|
|
|
error("hook declined to update %s", name);
|
|
|
|
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)) {
|
|
|
|
warning ("Allowing deletion of corrupt ref.");
|
|
|
|
old_sha1 = NULL;
|
|
|
|
}
|
2008-10-26 02:33:56 +00:00
|
|
|
if (delete_ref(name, old_sha1, 0)) {
|
2007-03-07 21:51:59 +00:00
|
|
|
error("failed to delete %s", name);
|
|
|
|
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) {
|
2007-03-07 21:51:59 +00:00
|
|
|
error("failed to lock %s", name);
|
|
|
|
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";
|
|
|
|
|
|
|
|
static void run_update_post_hook(struct command *cmd)
|
|
|
|
{
|
|
|
|
struct command *cmd_p;
|
2009-06-21 21:16:09 +00:00
|
|
|
int argc, status;
|
2006-03-05 10:47:29 +00:00
|
|
|
const char **argv;
|
2005-08-02 21:24:22 +00:00
|
|
|
|
2007-03-07 21:50:43 +00:00
|
|
|
for (argc = 0, cmd_p = cmd; cmd_p; cmd_p = cmd_p->next) {
|
2005-12-26 07:18:37 +00:00
|
|
|
if (cmd_p->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;
|
|
|
|
|
|
|
|
for (argc = 1, cmd_p = cmd; cmd_p; cmd_p = cmd_p->next) {
|
2006-03-05 10:47:29 +00:00
|
|
|
char *p;
|
2005-12-26 07:18:37 +00:00
|
|
|
if (cmd_p->error_string)
|
2005-08-02 21:24:22 +00:00
|
|
|
continue;
|
2006-03-05 10:47:29 +00:00
|
|
|
p = xmalloc(strlen(cmd_p->ref_name) + 1);
|
|
|
|
strcpy(p, cmd_p->ref_name);
|
|
|
|
argv[argc] = p;
|
2005-08-02 21:24:22 +00:00
|
|
|
argc++;
|
|
|
|
}
|
|
|
|
argv[argc] = NULL;
|
2009-06-21 21:16:09 +00:00
|
|
|
status = run_command_v_opt(argv, RUN_COMMAND_NO_STDIN
|
|
|
|
| RUN_COMMAND_STDOUT_TO_STDERR);
|
|
|
|
run_status(status, update_post_hook);
|
2005-08-02 21:24:22 +00:00
|
|
|
}
|
2005-06-30 17:15:22 +00:00
|
|
|
|
2007-03-07 21:51:59 +00:00
|
|
|
static void execute_commands(const char *unpacker_error)
|
2005-06-30 00:52:11 +00:00
|
|
|
{
|
2005-06-30 06:01:14 +00:00
|
|
|
struct command *cmd = commands;
|
2009-02-09 06:31:21 +00:00
|
|
|
unsigned char sha1[20];
|
2007-03-07 21:51:59 +00:00
|
|
|
|
|
|
|
if (unpacker_error) {
|
|
|
|
while (cmd) {
|
|
|
|
cmd->error_string = "n/a (unpacker error)";
|
|
|
|
cmd = cmd->next;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-01-16 19:09:59 +00:00
|
|
|
if (run_receive_hook(pre_receive_hook)) {
|
2007-03-07 21:52:05 +00:00
|
|
|
while (cmd) {
|
|
|
|
cmd->error_string = "pre-receive hook declined";
|
|
|
|
cmd = cmd->next;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-02-09 06:31:21 +00:00
|
|
|
head_name = resolve_ref("HEAD", sha1, 0, NULL);
|
|
|
|
|
2005-06-30 06:01:14 +00:00
|
|
|
while (cmd) {
|
2007-03-07 21:51:59 +00:00
|
|
|
cmd->error_string = update(cmd);
|
2005-06-30 06:01:14 +00:00
|
|
|
cmd = cmd->next;
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void read_head_info(void)
|
|
|
|
{
|
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;
|
|
|
|
}
|
2005-06-30 06:01:14 +00:00
|
|
|
cmd = xmalloc(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);
|
2007-03-07 21:51:59 +00:00
|
|
|
cmd->error_string = NULL;
|
2005-06-30 06:01:14 +00:00
|
|
|
cmd->next = NULL;
|
|
|
|
*p = cmd;
|
|
|
|
p = &cmd->next;
|
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;
|
|
|
|
|
2006-10-30 22:34:50 +00:00
|
|
|
static const char *unpack(void)
|
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";
|
|
|
|
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
|
|
|
run_status(code, unpacker[0]);
|
|
|
|
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) {
|
|
|
|
run_status(status, keeper[0]);
|
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;
|
|
|
|
}
|
2009-06-21 21:16:09 +00:00
|
|
|
run_status(status, keeper[0]);
|
2006-11-01 22:06:25 +00:00
|
|
|
return "index-pack abnormal exit";
|
2005-12-26 07:18:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void report(const char *unpack_status)
|
|
|
|
{
|
|
|
|
struct command *cmd;
|
|
|
|
packet_write(1, "unpack %s\n",
|
|
|
|
unpack_status ? unpack_status : "ok");
|
|
|
|
for (cmd = commands; cmd; cmd = cmd->next) {
|
|
|
|
if (!cmd->error_string)
|
|
|
|
packet_write(1, "ok %s\n",
|
|
|
|
cmd->ref_name);
|
|
|
|
else
|
|
|
|
packet_write(1, "ng %s %s\n",
|
|
|
|
cmd->ref_name, cmd->error_string);
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
2005-12-26 07:18:37 +00:00
|
|
|
packet_flush(1);
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
|
|
|
|
2006-11-24 08:26:49 +00:00
|
|
|
static int delete_only(struct command *cmd)
|
|
|
|
{
|
|
|
|
while (cmd) {
|
|
|
|
if (!is_null_sha1(cmd->new_sha1))
|
|
|
|
return 0;
|
|
|
|
cmd = cmd->next;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
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 int add_refs_from_alternate(struct alternate_object_database *e, void *unused)
|
|
|
|
{
|
2008-10-26 18:07:18 +00:00
|
|
|
char *other;
|
|
|
|
size_t len;
|
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
|
|
|
struct remote *remote;
|
|
|
|
struct transport *transport;
|
|
|
|
const struct ref *extra;
|
|
|
|
|
2008-10-26 18:07:18 +00:00
|
|
|
e->name[-1] = '\0';
|
|
|
|
other = xstrdup(make_absolute_path(e->base));
|
|
|
|
e->name[-1] = '/';
|
|
|
|
len = strlen(other);
|
|
|
|
|
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
|
|
|
while (other[len-1] == '/')
|
|
|
|
other[--len] = '\0';
|
|
|
|
if (len < 8 || memcmp(other + len - 8, "/objects", 8))
|
|
|
|
return 0;
|
|
|
|
/* Is this a git repository with refs? */
|
|
|
|
memcpy(other + len - 8, "/refs", 6);
|
|
|
|
if (!is_directory(other))
|
|
|
|
return 0;
|
|
|
|
other[len - 8] = '\0';
|
|
|
|
remote = remote_get(other);
|
|
|
|
transport = transport_get(remote, other);
|
|
|
|
for (extra = transport_get_remote_refs(transport);
|
|
|
|
extra;
|
|
|
|
extra = extra->next) {
|
|
|
|
add_extra_ref(".have", extra->old_sha1, 0);
|
|
|
|
}
|
|
|
|
transport_disconnect(transport);
|
|
|
|
free(other);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_alternate_refs(void)
|
|
|
|
{
|
|
|
|
foreach_alt_odb(add_refs_from_alternate, NULL);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2005-06-30 19:28:24 +00:00
|
|
|
int i;
|
2005-11-17 19:37:14 +00:00
|
|
|
char *dir = NULL;
|
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 == '-') {
|
|
|
|
/* Do flag handling here */
|
|
|
|
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-05-01 20:56:47 +00:00
|
|
|
capabilities_to_send = (prefer_ofs_delta) ?
|
|
|
|
" report-status delete-refs ofs-delta " :
|
|
|
|
" report-status delete-refs ";
|
|
|
|
|
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
|
|
|
add_alternate_refs();
|
2005-07-03 03:23:36 +00:00
|
|
|
write_head_info();
|
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
|
|
|
clear_extra_refs();
|
2005-06-30 00:52:11 +00:00
|
|
|
|
|
|
|
/* EOF */
|
2005-06-30 03:50:15 +00:00
|
|
|
packet_flush(1);
|
2005-06-30 00:52:11 +00:00
|
|
|
|
|
|
|
read_head_info();
|
2005-06-30 05:50:48 +00:00
|
|
|
if (commands) {
|
2006-11-24 08:26:49 +00:00
|
|
|
const char *unpack_status = NULL;
|
|
|
|
|
|
|
|
if (!delete_only(commands))
|
|
|
|
unpack_status = unpack();
|
2007-03-07 21:51:59 +00:00
|
|
|
execute_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)
|
|
|
|
report(unpack_status);
|
2009-01-16 19:09:59 +00:00
|
|
|
run_receive_hook(post_receive_hook);
|
2007-03-07 21:50:24 +00:00
|
|
|
run_update_post_hook(commands);
|
2005-06-30 05:50:48 +00:00
|
|
|
}
|
2005-06-30 00:52:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|