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
|
|
|
|
2005-07-31 19:17:43 +00:00
|
|
|
static char update_hook[] = "hooks/update";
|
|
|
|
|
|
|
|
static int run_update_hook(const char *refname,
|
|
|
|
char *old_hex, char *new_hex)
|
|
|
|
{
|
|
|
|
int code;
|
|
|
|
|
|
|
|
if (access(update_hook, X_OK) < 0)
|
|
|
|
return 0;
|
2006-12-31 02:55:22 +00:00
|
|
|
code = run_command_opt(RUN_COMMAND_NO_STDIN
|
|
|
|
| RUN_COMMAND_STDOUT_TO_STDERR,
|
2006-12-31 02:55:19 +00:00
|
|
|
update_hook, refname, old_hex, new_hex, NULL);
|
2005-07-31 19:17:43 +00:00
|
|
|
switch (code) {
|
|
|
|
case 0:
|
|
|
|
return 0;
|
|
|
|
case -ERR_RUN_COMMAND_FORK:
|
2005-12-26 07:18:37 +00:00
|
|
|
return error("hook fork failed");
|
2005-07-31 19:17:43 +00:00
|
|
|
case -ERR_RUN_COMMAND_EXEC:
|
2005-12-26 07:18:37 +00:00
|
|
|
return error("hook execute failed");
|
2005-07-31 19:17:43 +00:00
|
|
|
case -ERR_RUN_COMMAND_WAITPID:
|
2005-12-26 07:18:37 +00:00
|
|
|
return error("waitpid failed");
|
2005-07-31 19:17:43 +00:00
|
|
|
case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
|
2005-12-26 07:18:37 +00:00
|
|
|
return error("waitpid is confused");
|
2005-07-31 19:17:43 +00:00
|
|
|
case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
|
2006-02-23 01:47:10 +00:00
|
|
|
return error("%s died of signal", update_hook);
|
2005-07-31 19:17:43 +00:00
|
|
|
case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
|
2005-12-26 07:18:37 +00:00
|
|
|
return error("%s died strangely", update_hook);
|
2005-07-31 19:17:43 +00:00
|
|
|
default:
|
|
|
|
error("%s exited with error code %d", update_hook, -code);
|
|
|
|
return -code;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-26 07:18:37 +00:00
|
|
|
static int 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
|
|
|
char new_hex[41], old_hex[41];
|
|
|
|
struct ref_lock *lock;
|
2005-06-30 17:15:22 +00:00
|
|
|
|
2005-12-26 07:18:37 +00:00
|
|
|
cmd->error_string = NULL;
|
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)) {
|
2005-12-26 07:18:37 +00:00
|
|
|
cmd->error_string = "funny refname";
|
2005-10-14 01:57:39 +00:00
|
|
|
return error("refusing to create funny ref '%s' locally",
|
|
|
|
name);
|
2005-12-26 07:18:37 +00:00
|
|
|
}
|
2005-10-14 01:57:39 +00:00
|
|
|
|
2005-06-30 17:15:22 +00:00
|
|
|
strcpy(new_hex, sha1_to_hex(new_sha1));
|
2006-09-27 09:40:06 +00:00
|
|
|
strcpy(old_hex, sha1_to_hex(old_sha1));
|
2006-11-24 08:26:49 +00:00
|
|
|
|
|
|
|
if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
|
2005-12-26 07:18:37 +00:00
|
|
|
cmd->error_string = "bad pack";
|
2005-08-02 21:24:22 +00:00
|
|
|
return error("unpack should have generated %s, "
|
|
|
|
"but I can't find it!", new_hex);
|
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);
|
|
|
|
if (!ent)
|
2006-09-20 23:07:54 +00:00
|
|
|
return error("denying non-fast forward;"
|
2006-09-21 00:07:19 +00:00
|
|
|
" you should pull first");
|
2006-09-20 23:07:54 +00:00
|
|
|
}
|
2005-07-31 19:17:43 +00:00
|
|
|
if (run_update_hook(name, old_hex, new_hex)) {
|
2005-12-26 07:18:37 +00:00
|
|
|
cmd->error_string = "hook declined";
|
2006-02-23 01:47:10 +00:00
|
|
|
return error("hook declined to update %s", name);
|
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)) {
|
|
|
|
cmd->error_string = "failed to delete";
|
|
|
|
return error("failed to delete %s", name);
|
|
|
|
}
|
|
|
|
fprintf(stderr, "%s: %s -> deleted\n", name, old_hex);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
lock = lock_any_ref_for_update(name, old_sha1);
|
|
|
|
if (!lock) {
|
|
|
|
cmd->error_string = "failed to lock";
|
|
|
|
return error("failed to lock %s", name);
|
|
|
|
}
|
|
|
|
write_ref_sha1(lock, new_sha1, "push");
|
|
|
|
fprintf(stderr, "%s: %s -> %s\n", name, old_hex, new_hex);
|
2005-08-02 21:24:22 +00:00
|
|
|
}
|
2006-09-27 09:40:06 +00:00
|
|
|
return 0;
|
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
|
|
|
|
|
|
|
if (access(update_post_hook, X_OK) < 0)
|
|
|
|
return;
|
|
|
|
for (argc = 1, 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++;
|
|
|
|
}
|
|
|
|
argv = xmalloc(sizeof(*argv) * (1 + argc));
|
|
|
|
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
|
|
|
|
2005-06-30 00:52:11 +00:00
|
|
|
/*
|
|
|
|
* This gets called after(if) we've successfully
|
|
|
|
* unpacked the data payload.
|
|
|
|
*/
|
|
|
|
static void execute_commands(void)
|
|
|
|
{
|
2005-06-30 06:01:14 +00:00
|
|
|
struct command *cmd = commands;
|
|
|
|
|
|
|
|
while (cmd) {
|
2005-12-26 07:18:37 +00:00
|
|
|
update(cmd);
|
2005-06-30 06:01:14 +00:00
|
|
|
cmd = cmd->next;
|
2005-06-30 00:52:11 +00:00
|
|
|
}
|
2005-08-02 21:24:22 +00:00
|
|
|
run_update_post_hook(commands);
|
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);
|
2005-12-26 07:18:37 +00:00
|
|
|
cmd->error_string = "n/a (unpacker error)";
|
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];
|
|
|
|
int fd[2], s, len, status;
|
|
|
|
pid_t pid;
|
|
|
|
char keep_arg[256];
|
|
|
|
char packname[46];
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (pipe(fd) < 0)
|
|
|
|
return "index-pack pipe failed";
|
|
|
|
pid = fork();
|
|
|
|
if (pid < 0)
|
|
|
|
return "index-pack fork failed";
|
|
|
|
if (!pid) {
|
|
|
|
dup2(fd[1], 1);
|
|
|
|
close(fd[1]);
|
|
|
|
close(fd[0]);
|
|
|
|
execv_git_cmd(keeper);
|
|
|
|
die("execv of index-pack failed");
|
|
|
|
}
|
|
|
|
close(fd[1]);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The first thing we expects from index-pack's output
|
|
|
|
* is "pack\t%40s\n" or "keep\t%40s\n" (46 bytes) where
|
|
|
|
* %40s is the newly created pack SHA1 name. In the "keep"
|
|
|
|
* case, we need it to remove the corresponding .keep file
|
|
|
|
* later on. If we don't get that then tough luck with it.
|
|
|
|
*/
|
|
|
|
for (len = 0;
|
|
|
|
len < 46 && (s = xread(fd[0], packname+len, 46-len)) > 0;
|
|
|
|
len += s);
|
|
|
|
close(fd[0]);
|
|
|
|
if (len == 46 && packname[45] == '\n' &&
|
|
|
|
memcmp(packname, "keep\t", 5) == 0) {
|
|
|
|
char path[PATH_MAX];
|
|
|
|
packname[45] = 0;
|
|
|
|
snprintf(path, sizeof(path), "%s/pack/pack-%s.keep",
|
|
|
|
get_object_directory(), packname + 5);
|
|
|
|
pack_lockfile = xstrdup(path);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Then wrap our index-pack process. */
|
|
|
|
while (waitpid(pid, &status, 0) < 0)
|
|
|
|
if (errno != EINTR)
|
|
|
|
return "waitpid failed";
|
|
|
|
if (WIFEXITED(status)) {
|
|
|
|
int code = WEXITSTATUS(status);
|
|
|
|
if (code)
|
|
|
|
return "index-pack exited with error code";
|
|
|
|
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();
|
2005-12-26 07:18:37 +00:00
|
|
|
if (!unpack_status)
|
|
|
|
execute_commands();
|
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);
|
2005-06-30 05:50:48 +00:00
|
|
|
}
|
2005-06-30 00:52:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|