receive-pack: check connectivity before concluding "git push"
[git/git.git] / builtin / receive-pack.c
CommitLineData
1e4cd68c 1#include "builtin.h"
fc04c412 2#include "pack.h"
8a65ff76 3#include "refs.h"
f3a3214e 4#include "pkt-line.h"
38a81b4e 5#include "sideband.h"
b1bf95bb 6#include "run-command.h"
576162a4 7#include "exec_cmd.h"
11031d7e
JS
8#include "commit.h"
9#include "object.h"
d79796bc
JH
10#include "remote.h"
11#include "transport.h"
da3efdb1 12#include "string-list.h"
cff38a5e 13#include "sha1-array.h"
52fed6e1 14#include "connected.h"
575f4974 15
34263de0 16static const char receive_pack_usage[] = "git receive-pack <git-dir>";
575f4974 17
986e8239 18enum deny_action {
3d95d92b 19 DENY_UNCONFIGURED,
986e8239
JK
20 DENY_IGNORE,
21 DENY_WARN,
4b05548f 22 DENY_REFUSE
986e8239
JK
23};
24
1b53a076
JH
25static int deny_deletes;
26static int deny_non_fast_forwards;
3d95d92b 27static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
747ca245 28static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
20dc0016 29static int receive_fsck_objects;
e28714c5
JH
30static int receive_unpack_limit = -1;
31static int transfer_unpack_limit = -1;
46732fae 32static int unpack_limit = 100;
96f1e58f 33static int report_status;
38a81b4e 34static int use_sideband;
b74fce16 35static int prefer_ofs_delta = 1;
77e3efbf
JH
36static int auto_update_server_info;
37static int auto_gc = 1;
747ca245 38static const char *head_name;
185c04e0 39static int sent_capabilities;
cfee10a7 40
986e8239
JK
41static enum deny_action parse_deny_action(const char *var, const char *value)
42{
43 if (value) {
44 if (!strcasecmp(value, "ignore"))
45 return DENY_IGNORE;
46 if (!strcasecmp(value, "warn"))
47 return DENY_WARN;
48 if (!strcasecmp(value, "refuse"))
49 return DENY_REFUSE;
50 }
51 if (git_config_bool(var, value))
52 return DENY_REFUSE;
53 return DENY_IGNORE;
54}
55
ef90d6d4 56static int receive_pack_config(const char *var, const char *value, void *cb)
6fb75bed 57{
a240de11
JK
58 if (strcmp(var, "receive.denydeletes") == 0) {
59 deny_deletes = git_config_bool(var, value);
60 return 0;
61 }
62
e28714c5 63 if (strcmp(var, "receive.denynonfastforwards") == 0) {
6fb75bed
SP
64 deny_non_fast_forwards = git_config_bool(var, value);
65 return 0;
66 }
67
e28714c5
JH
68 if (strcmp(var, "receive.unpacklimit") == 0) {
69 receive_unpack_limit = git_config_int(var, value);
fc04c412
SP
70 return 0;
71 }
72
e28714c5
JH
73 if (strcmp(var, "transfer.unpacklimit") == 0) {
74 transfer_unpack_limit = git_config_int(var, value);
75 return 0;
76 }
77
20dc0016
MK
78 if (strcmp(var, "receive.fsckobjects") == 0) {
79 receive_fsck_objects = git_config_bool(var, value);
80 return 0;
81 }
82
986e8239
JK
83 if (!strcmp(var, "receive.denycurrentbranch")) {
84 deny_current_branch = parse_deny_action(var, value);
85 return 0;
86 }
87
747ca245
JH
88 if (strcmp(var, "receive.denydeletecurrent") == 0) {
89 deny_delete_current = parse_deny_action(var, value);
90 return 0;
91 }
92
b74fce16
NP
93 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
94 prefer_ofs_delta = git_config_bool(var, value);
95 return 0;
96 }
97
77e3efbf
JH
98 if (strcmp(var, "receive.updateserverinfo") == 0) {
99 auto_update_server_info = git_config_bool(var, value);
100 return 0;
101 }
102
103 if (strcmp(var, "receive.autogc") == 0) {
104 auto_gc = git_config_bool(var, value);
105 return 0;
106 }
107
ef90d6d4 108 return git_default_config(var, value, cb);
6fb75bed
SP
109}
110
8da19775 111static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
575f4974 112{
185c04e0 113 if (sent_capabilities)
cfee10a7
JH
114 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
115 else
185c04e0
SP
116 packet_write(1, "%s %s%c%s%s\n",
117 sha1_to_hex(sha1), path, 0,
38a81b4e 118 " report-status delete-refs side-band-64k",
185c04e0
SP
119 prefer_ofs_delta ? " ofs-delta" : "");
120 sent_capabilities = 1;
8a65ff76 121 return 0;
575f4974
LT
122}
123
8a65ff76 124static void write_head_info(void)
575f4974 125{
cb5d709f 126 for_each_ref(show_ref, NULL);
185c04e0 127 if (!sent_capabilities)
8da19775 128 show_ref("capabilities^{}", null_sha1, 0, NULL);
cfee10a7 129
575f4974
LT
130}
131
eb1af2df
LT
132struct command {
133 struct command *next;
cfee10a7 134 const char *error_string;
da3efdb1 135 unsigned int skip_update;
eb1af2df
LT
136 unsigned char old_sha1[20];
137 unsigned char new_sha1[20];
8f1d2e6f 138 char ref_name[FLEX_ARRAY]; /* more */
575f4974
LT
139};
140
05ef58ec
SP
141static const char pre_receive_hook[] = "hooks/pre-receive";
142static const char post_receive_hook[] = "hooks/post-receive";
b1bf95bb 143
466dbc42
SP
144static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
145static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
146
147static void report_message(const char *prefix, const char *err, va_list params)
148{
149 int sz = strlen(prefix);
150 char msg[4096];
151
152 strncpy(msg, prefix, sz);
153 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
154 if (sz > (sizeof(msg) - 1))
155 sz = sizeof(msg) - 1;
156 msg[sz++] = '\n';
157
158 if (use_sideband)
159 send_sideband(1, 2, msg, sz, use_sideband);
160 else
161 xwrite(2, msg, sz);
162}
163
164static void rp_warning(const char *err, ...)
165{
166 va_list params;
167 va_start(params, err);
168 report_message("warning: ", err, params);
169 va_end(params);
170}
171
172static void rp_error(const char *err, ...)
173{
174 va_list params;
175 va_start(params, err);
176 report_message("error: ", err, params);
177 va_end(params);
178}
179
6d525d38
SP
180static int copy_to_sideband(int in, int out, void *arg)
181{
182 char data[128];
183 while (1) {
184 ssize_t sz = xread(in, data, sizeof(data));
185 if (sz <= 0)
186 break;
187 send_sideband(1, 2, data, sz, use_sideband);
188 }
189 close(in);
190 return 0;
191}
192
5e1c71fd 193static int run_receive_hook(struct command *commands, const char *hook_name)
b1bf95bb 194{
f43cd49f 195 static char buf[sizeof(commands->old_sha1) * 2 + PATH_MAX + 4];
c8dd2771 196 struct command *cmd;
f43cd49f 197 struct child_process proc;
6d525d38 198 struct async muxer;
f43cd49f
SP
199 const char *argv[2];
200 int have_input = 0, code;
c8dd2771 201
f43cd49f 202 for (cmd = commands; !have_input && cmd; cmd = cmd->next) {
c8dd2771 203 if (!cmd->error_string)
f43cd49f 204 have_input = 1;
c8dd2771 205 }
b1bf95bb 206
f43cd49f 207 if (!have_input || access(hook_name, X_OK) < 0)
b1bf95bb 208 return 0;
c8dd2771 209
c8dd2771 210 argv[0] = hook_name;
f43cd49f
SP
211 argv[1] = NULL;
212
213 memset(&proc, 0, sizeof(proc));
214 proc.argv = argv;
215 proc.in = -1;
216 proc.stdout_to_stderr = 1;
217
6d525d38
SP
218 if (use_sideband) {
219 memset(&muxer, 0, sizeof(muxer));
220 muxer.proc = copy_to_sideband;
221 muxer.in = -1;
222 code = start_async(&muxer);
223 if (code)
224 return code;
225 proc.err = muxer.in;
226 }
227
f43cd49f 228 code = start_command(&proc);
6d525d38
SP
229 if (code) {
230 if (use_sideband)
231 finish_async(&muxer);
90e41a89 232 return code;
6d525d38
SP
233 }
234
f43cd49f 235 for (cmd = commands; cmd; cmd = cmd->next) {
c8dd2771 236 if (!cmd->error_string) {
f43cd49f
SP
237 size_t n = snprintf(buf, sizeof(buf), "%s %s %s\n",
238 sha1_to_hex(cmd->old_sha1),
239 sha1_to_hex(cmd->new_sha1),
240 cmd->ref_name);
241 if (write_in_full(proc.in, buf, n) != n)
242 break;
c8dd2771 243 }
c8dd2771 244 }
e72ae288 245 close(proc.in);
6d525d38
SP
246 if (use_sideband)
247 finish_async(&muxer);
90e41a89 248 return finish_command(&proc);
b1bf95bb
JW
249}
250
1d9e8b56
SP
251static int run_update_hook(struct command *cmd)
252{
253 static const char update_hook[] = "hooks/update";
1d9e8b56 254 const char *argv[5];
6d525d38
SP
255 struct child_process proc;
256 int code;
1d9e8b56
SP
257
258 if (access(update_hook, X_OK) < 0)
259 return 0;
260
261 argv[0] = update_hook;
262 argv[1] = cmd->ref_name;
263 argv[2] = sha1_to_hex(cmd->old_sha1);
264 argv[3] = sha1_to_hex(cmd->new_sha1);
265 argv[4] = NULL;
266
6d525d38
SP
267 memset(&proc, 0, sizeof(proc));
268 proc.no_stdin = 1;
269 proc.stdout_to_stderr = 1;
270 proc.err = use_sideband ? -1 : 0;
271 proc.argv = argv;
272
273 code = start_command(&proc);
274 if (code)
275 return code;
276 if (use_sideband)
277 copy_to_sideband(proc.err, -1, NULL);
278 return finish_command(&proc);
1d9e8b56
SP
279}
280
986e8239
JK
281static int is_ref_checked_out(const char *ref)
282{
986e8239
JK
283 if (is_bare_repository())
284 return 0;
285
747ca245 286 if (!head_name)
986e8239 287 return 0;
747ca245 288 return !strcmp(head_name, ref);
986e8239
JK
289}
290
acd2a45b
JH
291static char *refuse_unconfigured_deny_msg[] = {
292 "By default, updating the current branch in a non-bare repository",
293 "is denied, because it will make the index and work tree inconsistent",
294 "with what you pushed, and will require 'git reset --hard' to match",
295 "the work tree to HEAD.",
3d95d92b
JH
296 "",
297 "You can set 'receive.denyCurrentBranch' configuration variable to",
acd2a45b
JH
298 "'ignore' or 'warn' in the remote repository to allow pushing into",
299 "its current branch; however, this is not recommended unless you",
300 "arranged to update its work tree to match what you pushed in some",
301 "other way.",
3d95d92b 302 "",
acd2a45b
JH
303 "To squelch this message and still keep the default behaviour, set",
304 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
3d95d92b
JH
305};
306
acd2a45b 307static void refuse_unconfigured_deny(void)
3d95d92b
JH
308{
309 int i;
acd2a45b 310 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
a886ba28 311 rp_error("%s", refuse_unconfigured_deny_msg[i]);
3d95d92b
JH
312}
313
375881fa
JH
314static char *refuse_unconfigured_deny_delete_current_msg[] = {
315 "By default, deleting the current branch is denied, because the next",
316 "'git clone' won't result in any file checked out, causing confusion.",
747ca245
JH
317 "",
318 "You can set 'receive.denyDeleteCurrent' configuration variable to",
375881fa
JH
319 "'warn' or 'ignore' in the remote repository to allow deleting the",
320 "current branch, with or without a warning message.",
747ca245 321 "",
375881fa 322 "To squelch this message, you can set it to 'refuse'."
747ca245
JH
323};
324
375881fa 325static void refuse_unconfigured_deny_delete_current(void)
747ca245
JH
326{
327 int i;
328 for (i = 0;
375881fa 329 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
747ca245 330 i++)
a886ba28 331 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
747ca245
JH
332}
333
8aaf7d64 334static const char *update(struct command *cmd)
2eca23da 335{
cfee10a7
JH
336 const char *name = cmd->ref_name;
337 unsigned char *old_sha1 = cmd->old_sha1;
338 unsigned char *new_sha1 = cmd->new_sha1;
3159c8dc 339 struct ref_lock *lock;
2eca23da 340
061d6b9a
MK
341 /* only refs/... are allowed */
342 if (prefixcmp(name, "refs/") || check_ref_format(name + 5)) {
466dbc42 343 rp_error("refusing to create funny ref '%s' remotely", name);
8aaf7d64 344 return "funny refname";
cfee10a7 345 }
d8a1deec 346
3d95d92b
JH
347 if (is_ref_checked_out(name)) {
348 switch (deny_current_branch) {
349 case DENY_IGNORE:
986e8239 350 break;
3d95d92b 351 case DENY_WARN:
466dbc42 352 rp_warning("updating the current branch");
986e8239 353 break;
3d95d92b 354 case DENY_REFUSE:
acd2a45b 355 case DENY_UNCONFIGURED:
466dbc42 356 rp_error("refusing to update checked out branch: %s", name);
acd2a45b
JH
357 if (deny_current_branch == DENY_UNCONFIGURED)
358 refuse_unconfigured_deny();
3d95d92b
JH
359 return "branch is currently checked out";
360 }
986e8239
JK
361 }
362
d4f694ba 363 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
8aaf7d64
SP
364 error("unpack should have generated %s, "
365 "but I can't find it!", sha1_to_hex(new_sha1));
366 return "bad pack";
cfee10a7 367 }
747ca245
JH
368
369 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
370 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
466dbc42 371 rp_error("denying ref deletion for %s", name);
747ca245
JH
372 return "deletion prohibited";
373 }
374
375 if (!strcmp(name, head_name)) {
376 switch (deny_delete_current) {
377 case DENY_IGNORE:
378 break;
379 case DENY_WARN:
466dbc42 380 rp_warning("deleting the current branch");
747ca245
JH
381 break;
382 case DENY_REFUSE:
375881fa
JH
383 case DENY_UNCONFIGURED:
384 if (deny_delete_current == DENY_UNCONFIGURED)
385 refuse_unconfigured_deny_delete_current();
466dbc42 386 rp_error("refusing to delete the current branch: %s", name);
747ca245
JH
387 return "deletion of the current branch prohibited";
388 }
389 }
a240de11 390 }
747ca245 391
d4f694ba 392 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
ba988a83 393 !is_null_sha1(old_sha1) &&
cc44c765 394 !prefixcmp(name, "refs/heads/")) {
eab82707 395 struct object *old_object, *new_object;
11031d7e 396 struct commit *old_commit, *new_commit;
9edd7e46 397 struct commit_list *bases, *ent;
11031d7e 398
eab82707
MK
399 old_object = parse_object(old_sha1);
400 new_object = parse_object(new_sha1);
401
402 if (!old_object || !new_object ||
403 old_object->type != OBJ_COMMIT ||
404 new_object->type != OBJ_COMMIT) {
405 error("bad sha1 objects for %s", name);
406 return "bad ref";
407 }
408 old_commit = (struct commit *)old_object;
409 new_commit = (struct commit *)new_object;
9edd7e46
JS
410 bases = get_merge_bases(old_commit, new_commit, 1);
411 for (ent = bases; ent; ent = ent->next)
412 if (!hashcmp(old_sha1, ent->item->object.sha1))
11031d7e 413 break;
9edd7e46 414 free_commit_list(bases);
8aaf7d64 415 if (!ent) {
466dbc42
SP
416 rp_error("denying non-fast-forward %s"
417 " (you should pull first)", name);
a75d7b54 418 return "non-fast-forward";
8aaf7d64 419 }
11031d7e 420 }
1d9e8b56 421 if (run_update_hook(cmd)) {
466dbc42 422 rp_error("hook declined to update %s", name);
8aaf7d64 423 return "hook declined";
b1bf95bb 424 }
3159c8dc 425
d4f694ba 426 if (is_null_sha1(new_sha1)) {
28391a80 427 if (!parse_object(old_sha1)) {
466dbc42 428 rp_warning("Allowing deletion of corrupt ref.");
28391a80
JS
429 old_sha1 = NULL;
430 }
eca35a25 431 if (delete_ref(name, old_sha1, 0)) {
466dbc42 432 rp_error("failed to delete %s", name);
8aaf7d64 433 return "failed to delete";
d4f694ba 434 }
8aaf7d64 435 return NULL; /* good */
d4f694ba
JH
436 }
437 else {
68db31cc 438 lock = lock_any_ref_for_update(name, old_sha1, 0);
d4f694ba 439 if (!lock) {
466dbc42 440 rp_error("failed to lock %s", name);
8aaf7d64 441 return "failed to lock";
d4f694ba 442 }
ef203f08 443 if (write_ref_sha1(lock, new_sha1, "push")) {
8aaf7d64 444 return "failed to write"; /* error() already called */
ef203f08 445 }
8aaf7d64 446 return NULL; /* good */
19614330 447 }
2eca23da
LT
448}
449
19614330
JH
450static char update_post_hook[] = "hooks/post-update";
451
5e1c71fd 452static void run_update_post_hook(struct command *commands)
19614330 453{
5e1c71fd 454 struct command *cmd;
6d525d38 455 int argc;
9201c707 456 const char **argv;
6d525d38 457 struct child_process proc;
19614330 458
5e1c71fd
JS
459 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
460 if (cmd->error_string)
19614330
JH
461 continue;
462 argc++;
463 }
3e6e152c
SP
464 if (!argc || access(update_post_hook, X_OK) < 0)
465 return;
466 argv = xmalloc(sizeof(*argv) * (2 + argc));
19614330
JH
467 argv[0] = update_post_hook;
468
5e1c71fd 469 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
9201c707 470 char *p;
5e1c71fd 471 if (cmd->error_string)
19614330 472 continue;
5e1c71fd
JS
473 p = xmalloc(strlen(cmd->ref_name) + 1);
474 strcpy(p, cmd->ref_name);
9201c707 475 argv[argc] = p;
19614330
JH
476 argc++;
477 }
478 argv[argc] = NULL;
6d525d38
SP
479
480 memset(&proc, 0, sizeof(proc));
481 proc.no_stdin = 1;
482 proc.stdout_to_stderr = 1;
483 proc.err = use_sideband ? -1 : 0;
484 proc.argv = argv;
485
486 if (!start_command(&proc)) {
487 if (use_sideband)
488 copy_to_sideband(proc.err, -1, NULL);
489 finish_command(&proc);
490 }
19614330 491}
2eca23da 492
da3efdb1
JS
493static void check_aliased_update(struct command *cmd, struct string_list *list)
494{
495 struct string_list_item *item;
496 struct command *dst_cmd;
497 unsigned char sha1[20];
498 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
499 int flag;
500
501 const char *dst_name = resolve_ref(cmd->ref_name, sha1, 0, &flag);
502
503 if (!(flag & REF_ISSYMREF))
504 return;
505
e8c8b713 506 if ((item = string_list_lookup(list, dst_name)) == NULL)
da3efdb1
JS
507 return;
508
509 cmd->skip_update = 1;
510
511 dst_cmd = (struct command *) item->util;
512
513 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
514 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
515 return;
516
517 dst_cmd->skip_update = 1;
518
519 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
0e71bc30 520 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
da3efdb1 521 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
0e71bc30 522 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
da3efdb1
JS
523 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
524 " its target '%s' (%s..%s)",
525 cmd->ref_name, cmd_oldh, cmd_newh,
526 dst_cmd->ref_name, dst_oldh, dst_newh);
527
528 cmd->error_string = dst_cmd->error_string =
529 "inconsistent aliased update";
530}
531
532static void check_aliased_updates(struct command *commands)
533{
534 struct command *cmd;
183113a5 535 struct string_list ref_list = STRING_LIST_INIT_NODUP;
da3efdb1
JS
536
537 for (cmd = commands; cmd; cmd = cmd->next) {
538 struct string_list_item *item =
1d2f80fa 539 string_list_append(&ref_list, cmd->ref_name);
da3efdb1
JS
540 item->util = (void *)cmd;
541 }
542 sort_string_list(&ref_list);
543
544 for (cmd = commands; cmd; cmd = cmd->next)
545 check_aliased_update(cmd, &ref_list);
546
547 string_list_clear(&ref_list, 0);
548}
549
52fed6e1
JH
550static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
551{
552 struct command **cmd_list = cb_data;
553 struct command *cmd = *cmd_list;
554
555 if (!cmd)
556 return -1; /* end of list */
557 *cmd_list = NULL; /* this returns only one */
558 hashcpy(sha1, cmd->new_sha1);
559 return 0;
560}
561
562static void set_connectivity_errors(struct command *commands)
563{
564 struct command *cmd;
565
566 for (cmd = commands; cmd; cmd = cmd->next) {
567 struct command *singleton = cmd;
568 if (!check_everything_connected(command_singleton_iterator,
569 0, &singleton))
570 continue;
571 cmd->error_string = "missing necessary objects";
572 }
573}
574
575static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
576{
577 struct command **cmd_list = cb_data;
578 struct command *cmd = *cmd_list;
579
580 if (!cmd)
581 return -1; /* end of list */
582 *cmd_list = cmd->next;
583 hashcpy(sha1, cmd->new_sha1);
584 return 0;
585}
586
5e1c71fd 587static void execute_commands(struct command *commands, const char *unpacker_error)
575f4974 588{
5e1c71fd 589 struct command *cmd;
747ca245 590 unsigned char sha1[20];
8aaf7d64
SP
591
592 if (unpacker_error) {
5e1c71fd 593 for (cmd = commands; cmd; cmd = cmd->next)
8aaf7d64 594 cmd->error_string = "n/a (unpacker error)";
8aaf7d64
SP
595 return;
596 }
597
52fed6e1
JH
598 cmd = commands;
599 if (check_everything_connected(iterate_receive_command_list,
600 0, &cmd))
601 set_connectivity_errors(commands);
602
5e1c71fd
JS
603 if (run_receive_hook(commands, pre_receive_hook)) {
604 for (cmd = commands; cmd; cmd = cmd->next)
05ef58ec 605 cmd->error_string = "pre-receive hook declined";
05ef58ec
SP
606 return;
607 }
608
da3efdb1
JS
609 check_aliased_updates(commands);
610
747ca245
JH
611 head_name = resolve_ref("HEAD", sha1, 0, NULL);
612
5e1c71fd 613 for (cmd = commands; cmd; cmd = cmd->next)
da3efdb1
JS
614 if (!cmd->skip_update)
615 cmd->error_string = update(cmd);
575f4974
LT
616}
617
5e1c71fd 618static struct command *read_head_info(void)
575f4974 619{
5e1c71fd 620 struct command *commands = NULL;
eb1af2df 621 struct command **p = &commands;
575f4974
LT
622 for (;;) {
623 static char line[1000];
eb1af2df
LT
624 unsigned char old_sha1[20], new_sha1[20];
625 struct command *cmd;
cfee10a7
JH
626 char *refname;
627 int len, reflen;
eb1af2df
LT
628
629 len = packet_read_line(0, line, sizeof(line));
575f4974
LT
630 if (!len)
631 break;
eb1af2df
LT
632 if (line[len-1] == '\n')
633 line[--len] = 0;
634 if (len < 83 ||
635 line[40] != ' ' ||
636 line[81] != ' ' ||
637 get_sha1_hex(line, old_sha1) ||
638 get_sha1_hex(line + 41, new_sha1))
cfee10a7
JH
639 die("protocol error: expected old/new/ref, got '%s'",
640 line);
641
642 refname = line + 82;
643 reflen = strlen(refname);
644 if (reflen + 82 < len) {
645 if (strstr(refname + reflen + 1, "report-status"))
646 report_status = 1;
38a81b4e
SP
647 if (strstr(refname + reflen + 1, "side-band-64k"))
648 use_sideband = LARGE_PACKET_MAX;
cfee10a7 649 }
da3efdb1 650 cmd = xcalloc(1, sizeof(struct command) + len - 80);
e702496e
SP
651 hashcpy(cmd->old_sha1, old_sha1);
652 hashcpy(cmd->new_sha1, new_sha1);
eb1af2df 653 memcpy(cmd->ref_name, line + 82, len - 81);
eb1af2df
LT
654 *p = cmd;
655 p = &cmd->next;
575f4974 656 }
5e1c71fd 657 return commands;
575f4974
LT
658}
659
fc04c412
SP
660static const char *parse_pack_header(struct pack_header *hdr)
661{
a69e5429
JH
662 switch (read_pack_header(0, hdr)) {
663 case PH_ERROR_EOF:
664 return "eof before pack header was fully read";
665
666 case PH_ERROR_PACK_SIGNATURE:
fc04c412 667 return "protocol error (pack signature mismatch detected)";
a69e5429
JH
668
669 case PH_ERROR_PROTOCOL:
fc04c412 670 return "protocol error (pack version unsupported)";
a69e5429
JH
671
672 default:
673 return "unknown error in parse_pack_header";
674
675 case 0:
676 return NULL;
677 }
fc04c412
SP
678}
679
576162a4
NP
680static const char *pack_lockfile;
681
861ed121 682static const char *unpack(void)
575f4974 683{
fc04c412
SP
684 struct pack_header hdr;
685 const char *hdr_err;
686 char hdr_arg[38];
fc04c412
SP
687
688 hdr_err = parse_pack_header(&hdr);
689 if (hdr_err)
690 return hdr_err;
6e1c2344
RJ
691 snprintf(hdr_arg, sizeof(hdr_arg),
692 "--pack_header=%"PRIu32",%"PRIu32,
fc04c412
SP
693 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
694
695 if (ntohl(hdr.hdr_entries) < unpack_limit) {
20dc0016
MK
696 int code, i = 0;
697 const char *unpacker[4];
698 unpacker[i++] = "unpack-objects";
699 if (receive_fsck_objects)
700 unpacker[i++] = "--strict";
701 unpacker[i++] = hdr_arg;
702 unpacker[i++] = NULL;
9b0b5093 703 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
2ff4d1ab 704 if (!code)
fc04c412 705 return NULL;
2ff4d1ab 706 return "unpack-objects abnormal exit";
576162a4 707 } else {
20dc0016
MK
708 const char *keeper[7];
709 int s, status, i = 0;
576162a4 710 char keep_arg[256];
e8016abf 711 struct child_process ip;
576162a4 712
85e72830 713 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
576162a4
NP
714 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
715 strcpy(keep_arg + s, "localhost");
716
20dc0016
MK
717 keeper[i++] = "index-pack";
718 keeper[i++] = "--stdin";
719 if (receive_fsck_objects)
720 keeper[i++] = "--strict";
721 keeper[i++] = "--fix-thin";
722 keeper[i++] = hdr_arg;
723 keeper[i++] = keep_arg;
724 keeper[i++] = NULL;
e8016abf
SP
725 memset(&ip, 0, sizeof(ip));
726 ip.argv = keeper;
727 ip.out = -1;
728 ip.git_cmd = 1;
2ff4d1ab
JS
729 status = start_command(&ip);
730 if (status) {
576162a4 731 return "index-pack fork failed";
2ff4d1ab 732 }
106764e6 733 pack_lockfile = index_pack_lockfile(ip.out);
e72ae288 734 close(ip.out);
e8016abf
SP
735 status = finish_command(&ip);
736 if (!status) {
576162a4
NP
737 reprepare_packed_git();
738 return NULL;
739 }
740 return "index-pack abnormal exit";
cfee10a7
JH
741 }
742}
743
5e1c71fd 744static void report(struct command *commands, const char *unpack_status)
cfee10a7
JH
745{
746 struct command *cmd;
38a81b4e
SP
747 struct strbuf buf = STRBUF_INIT;
748
749 packet_buf_write(&buf, "unpack %s\n",
750 unpack_status ? unpack_status : "ok");
cfee10a7
JH
751 for (cmd = commands; cmd; cmd = cmd->next) {
752 if (!cmd->error_string)
38a81b4e
SP
753 packet_buf_write(&buf, "ok %s\n",
754 cmd->ref_name);
cfee10a7 755 else
38a81b4e
SP
756 packet_buf_write(&buf, "ng %s %s\n",
757 cmd->ref_name, cmd->error_string);
575f4974 758 }
38a81b4e
SP
759 packet_buf_flush(&buf);
760
761 if (use_sideband)
762 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
763 else
764 safe_write(1, buf.buf, buf.len);
765 strbuf_release(&buf);
575f4974
LT
766}
767
5e1c71fd 768static int delete_only(struct command *commands)
d4f694ba 769{
5e1c71fd
JS
770 struct command *cmd;
771 for (cmd = commands; cmd; cmd = cmd->next) {
d4f694ba
JH
772 if (!is_null_sha1(cmd->new_sha1))
773 return 0;
d4f694ba
JH
774 }
775 return 1;
776}
777
cff38a5e 778static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
d79796bc 779{
cff38a5e
JK
780 add_extra_ref(".have", sha1, 0);
781}
782
783static void collect_one_alternate_ref(const struct ref *ref, void *data)
784{
785 struct sha1_array *sa = data;
786 sha1_array_append(sa, ref->old_sha1);
d79796bc
JH
787}
788
789static void add_alternate_refs(void)
790{
cff38a5e
JK
791 struct sha1_array sa = SHA1_ARRAY_INIT;
792 for_each_alternate_ref(collect_one_alternate_ref, &sa);
793 sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
794 sha1_array_clear(&sa);
d79796bc
JH
795}
796
be5908ae 797int cmd_receive_pack(int argc, const char **argv, const char *prefix)
575f4974 798{
42526b47
SP
799 int advertise_refs = 0;
800 int stateless_rpc = 0;
d0efc8a7 801 int i;
8d630132 802 char *dir = NULL;
5e1c71fd 803 struct command *commands;
575f4974 804
bbc30f99
JK
805 packet_trace_identity("receive-pack");
806
575f4974
LT
807 argv++;
808 for (i = 1; i < argc; i++) {
be5908ae 809 const char *arg = *argv++;
575f4974
LT
810
811 if (*arg == '-') {
42526b47
SP
812 if (!strcmp(arg, "--advertise-refs")) {
813 advertise_refs = 1;
814 continue;
815 }
816 if (!strcmp(arg, "--stateless-rpc")) {
817 stateless_rpc = 1;
818 continue;
819 }
820
575f4974
LT
821 usage(receive_pack_usage);
822 }
d0efc8a7
LT
823 if (dir)
824 usage(receive_pack_usage);
be5908ae 825 dir = xstrdup(arg);
575f4974
LT
826 }
827 if (!dir)
828 usage(receive_pack_usage);
829
e1464ca7 830 setup_path();
5c09f321 831
3159c8dc 832 if (!enter_repo(dir, 0))
05ac6b34 833 die("'%s' does not appear to be a git repository", dir);
575f4974 834
a0022eeb
JH
835 if (is_repository_shallow())
836 die("attempt to push into a shallow repository");
837
ef90d6d4 838 git_config(receive_pack_config, NULL);
6fb75bed 839
e28714c5
JH
840 if (0 <= transfer_unpack_limit)
841 unpack_limit = transfer_unpack_limit;
842 else if (0 <= receive_unpack_limit)
843 unpack_limit = receive_unpack_limit;
844
42526b47
SP
845 if (advertise_refs || !stateless_rpc) {
846 add_alternate_refs();
847 write_head_info();
848 clear_extra_refs();
575f4974 849
42526b47
SP
850 /* EOF */
851 packet_flush(1);
852 }
853 if (advertise_refs)
854 return 0;
575f4974 855
5e1c71fd 856 if ((commands = read_head_info()) != NULL) {
d4f694ba
JH
857 const char *unpack_status = NULL;
858
859 if (!delete_only(commands))
860 unpack_status = unpack();
5e1c71fd 861 execute_commands(commands, unpack_status);
576162a4 862 if (pack_lockfile)
691f1a28 863 unlink_or_warn(pack_lockfile);
cfee10a7 864 if (report_status)
5e1c71fd
JS
865 report(commands, unpack_status);
866 run_receive_hook(commands, post_receive_hook);
8e663d9e 867 run_update_post_hook(commands);
77e3efbf
JH
868 if (auto_gc) {
869 const char *argv_gc_auto[] = {
870 "gc", "--auto", "--quiet", NULL,
871 };
872 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
873 }
874 if (auto_update_server_info)
875 update_server_info(0);
7f8e9828 876 }
38a81b4e
SP
877 if (use_sideband)
878 packet_flush(1);
575f4974
LT
879 return 0;
880}