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"
|
2005-06-30 00:52:11 +00:00
|
|
|
|
2005-06-30 19:28:24 +00:00
|
|
|
static const char receive_pack_usage[] = "git-receive-pack <git-dir>";
|
2005-06-30 00:52:11 +00:00
|
|
|
|
2006-10-30 22:35:18 +00:00
|
|
|
static int deny_non_fast_forwards = 0;
|
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;
|
2005-12-26 07:18:37 +00:00
|
|
|
|
2006-11-24 08:26:49 +00:00
|
|
|
static char capabilities[] = " report-status delete-refs ";
|
2006-08-15 17:23:48 +00:00
|
|
|
static int capabilities_sent;
|
2005-12-26 07:18:37 +00:00
|
|
|
|
2006-10-30 22:35:18 +00:00
|
|
|
static int receive_pack_config(const char *var, const char *value)
|
|
|
|
{
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
return git_default_config(var, value);
|
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
|
|
|
{
|
2005-12-26 07:18:37 +00:00
|
|
|
if (capabilities_sent)
|
|
|
|
packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
|
|
|
|
else
|
|
|
|
packet_write(1, "%s %s%c%s\n",
|
|
|
|
sha1_to_hex(sha1), path, 0, capabilities);
|
|
|
|
capabilities_sent = 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);
|
2005-12-26 07:18:37 +00:00
|
|
|
if (!capabilities_sent)
|
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
|
|
|
|
2007-03-10 08:28:11 +00:00
|
|
|
static int hook_status(int code, const char *hook_name)
|
|
|
|
{
|
|
|
|
switch (code) {
|
|
|
|
case 0:
|
|
|
|
return 0;
|
|
|
|
case -ERR_RUN_COMMAND_FORK:
|
|
|
|
return error("hook fork failed");
|
|
|
|
case -ERR_RUN_COMMAND_EXEC:
|
|
|
|
return error("hook execute failed");
|
2007-03-10 08:28:16 +00:00
|
|
|
case -ERR_RUN_COMMAND_PIPE:
|
|
|
|
return error("hook pipe failed");
|
2007-03-10 08:28:11 +00:00
|
|
|
case -ERR_RUN_COMMAND_WAITPID:
|
|
|
|
return error("waitpid failed");
|
|
|
|
case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
|
|
|
|
return error("waitpid is confused");
|
|
|
|
case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
|
|
|
|
return error("%s died of signal", hook_name);
|
|
|
|
case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
|
|
|
|
return error("%s died strangely", hook_name);
|
|
|
|
default:
|
|
|
|
error("%s exited with error code %d", hook_name, -code);
|
|
|
|
return -code;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-03-10 08:28:16 +00:00
|
|
|
static int run_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)
|
|
|
|
return hook_status(code, hook_name);
|
|
|
|
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
|
|
|
}
|
|
|
|
}
|
2007-03-10 08:28:16 +00:00
|
|
|
return hook_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";
|
|
|
|
struct child_process proc;
|
|
|
|
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;
|
|
|
|
|
|
|
|
memset(&proc, 0, sizeof(proc));
|
|
|
|
proc.argv = argv;
|
|
|
|
proc.no_stdin = 1;
|
|
|
|
proc.stdout_to_stderr = 1;
|
|
|
|
|
|
|
|
return hook_status(run_command(&proc), update_hook);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
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
|
|
|
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
|
|
|
|
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
|
|
|
}
|
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/")) {
|
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
|
|
|
|
|
|
|
old_commit = (struct commit *)parse_object(old_sha1);
|
|
|
|
new_commit = (struct commit *)parse_object(new_sha1);
|
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)) {
|
|
|
|
if (delete_ref(name, old_sha1)) {
|
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:09 +00:00
|
|
|
fprintf(stderr, "%s: %s -> deleted\n", name,
|
|
|
|
sha1_to_hex(old_sha1));
|
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:09 +00:00
|
|
|
fprintf(stderr, "%s: %s -> %s\n", name,
|
|
|
|
sha1_to_hex(old_sha1), sha1_to_hex(new_sha1));
|
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;
|
|
|
|
int argc;
|
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;
|
2006-12-31 02:55:22 +00:00
|
|
|
run_command_v_opt(argv, RUN_COMMAND_NO_STDIN
|
|
|
|
| RUN_COMMAND_STDOUT_TO_STDERR);
|
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;
|
2007-03-07 21:51:59 +00:00
|
|
|
|
|
|
|
if (unpacker_error) {
|
|
|
|
while (cmd) {
|
|
|
|
cmd->error_string = "n/a (unpacker error)";
|
|
|
|
cmd = cmd->next;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-03-10 08:28:16 +00:00
|
|
|
if (run_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;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
snprintf(hdr_arg, sizeof(hdr_arg), "--pack_header=%u,%u",
|
|
|
|
ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
|
|
|
|
|
|
|
|
if (ntohl(hdr.hdr_entries) < unpack_limit) {
|
2006-11-01 22:06:25 +00:00
|
|
|
int code;
|
2006-11-01 22:06:21 +00:00
|
|
|
const char *unpacker[3];
|
|
|
|
unpacker[0] = "unpack-objects";
|
|
|
|
unpacker[1] = hdr_arg;
|
|
|
|
unpacker[2] = NULL;
|
2006-12-31 02:55:15 +00:00
|
|
|
code = run_command_v_opt(unpacker, RUN_GIT_CMD);
|
2006-11-01 22:06:25 +00:00
|
|
|
switch (code) {
|
2006-11-01 22:06:21 +00:00
|
|
|
case 0:
|
|
|
|
return NULL;
|
|
|
|
case -ERR_RUN_COMMAND_FORK:
|
|
|
|
return "unpack fork failed";
|
|
|
|
case -ERR_RUN_COMMAND_EXEC:
|
|
|
|
return "unpack execute failed";
|
|
|
|
case -ERR_RUN_COMMAND_WAITPID:
|
|
|
|
return "waitpid failed";
|
|
|
|
case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
|
|
|
|
return "waitpid is confused";
|
|
|
|
case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
|
|
|
|
return "unpacker died of signal";
|
|
|
|
case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
|
|
|
|
return "unpacker died strangely";
|
|
|
|
default:
|
|
|
|
return "unpacker exited with error code";
|
2006-11-01 22:06:25 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const char *keeper[6];
|
2007-09-14 07:31:16 +00:00
|
|
|
int s, status;
|
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
|
|
|
|
|
|
|
s = sprintf(keep_arg, "--keep=receive-pack %i on ", getpid());
|
|
|
|
if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
|
|
|
|
strcpy(keep_arg + s, "localhost");
|
|
|
|
|
|
|
|
keeper[0] = "index-pack";
|
|
|
|
keeper[1] = "--stdin";
|
|
|
|
keeper[2] = "--fix-thin";
|
|
|
|
keeper[3] = hdr_arg;
|
|
|
|
keeper[4] = keep_arg;
|
|
|
|
keeper[5] = NULL;
|
2007-03-12 23:00:26 +00:00
|
|
|
memset(&ip, 0, sizeof(ip));
|
|
|
|
ip.argv = keeper;
|
|
|
|
ip.out = -1;
|
|
|
|
ip.git_cmd = 1;
|
|
|
|
if (start_command(&ip))
|
2006-11-01 22:06:25 +00:00
|
|
|
return "index-pack fork failed";
|
2007-09-14 07:31:16 +00:00
|
|
|
pack_lockfile = index_pack_lockfile(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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2005-06-30 00:52:11 +00:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
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++) {
|
2005-11-17 19:37:14 +00:00
|
|
|
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);
|
2005-06-30 00:52:11 +00:00
|
|
|
dir = arg;
|
|
|
|
}
|
|
|
|
if (!dir)
|
|
|
|
usage(receive_pack_usage);
|
|
|
|
|
2006-09-27 09:40:06 +00:00
|
|
|
if (!enter_repo(dir, 0))
|
2005-11-17 19:37:14 +00:00
|
|
|
die("'%s': unable to chdir or not a git archive", 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");
|
|
|
|
|
2006-10-30 22:35:18 +00:00
|
|
|
git_config(receive_pack_config);
|
|
|
|
|
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;
|
|
|
|
|
2005-07-03 03:23:36 +00:00
|
|
|
write_head_info();
|
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)
|
|
|
|
unlink(pack_lockfile);
|
2005-12-26 07:18:37 +00:00
|
|
|
if (report_status)
|
|
|
|
report(unpack_status);
|
2007-03-10 08:28:16 +00:00
|
|
|
run_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;
|
|
|
|
}
|