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