receive-pack: check connectivity before concluding "git push"
[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 #include "connected.h"
15
16 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
17
18 enum deny_action {
19 DENY_UNCONFIGURED,
20 DENY_IGNORE,
21 DENY_WARN,
22 DENY_REFUSE
23 };
24
25 static int deny_deletes;
26 static int deny_non_fast_forwards;
27 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
28 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
29 static int receive_fsck_objects;
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, "receive.denycurrentbranch")) {
84 deny_current_branch = parse_deny_action(var, value);
85 return 0;
86 }
87
88 if (strcmp(var, "receive.denydeletecurrent") == 0) {
89 deny_delete_current = parse_deny_action(var, value);
90 return 0;
91 }
92
93 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
94 prefer_ofs_delta = git_config_bool(var, value);
95 return 0;
96 }
97
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
108 return git_default_config(var, value, cb);
109 }
110
111 static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
112 {
113 if (sent_capabilities)
114 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
115 else
116 packet_write(1, "%s %s%c%s%s\n",
117 sha1_to_hex(sha1), path, 0,
118 " report-status delete-refs side-band-64k",
119 prefer_ofs_delta ? " ofs-delta" : "");
120 sent_capabilities = 1;
121 return 0;
122 }
123
124 static void write_head_info(void)
125 {
126 for_each_ref(show_ref, NULL);
127 if (!sent_capabilities)
128 show_ref("capabilities^{}", null_sha1, 0, NULL);
129
130 }
131
132 struct command {
133 struct command *next;
134 const char *error_string;
135 unsigned int skip_update;
136 unsigned char old_sha1[20];
137 unsigned char new_sha1[20];
138 char ref_name[FLEX_ARRAY]; /* more */
139 };
140
141 static const char pre_receive_hook[] = "hooks/pre-receive";
142 static const char post_receive_hook[] = "hooks/post-receive";
143
144 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
145 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
146
147 static 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
164 static 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
172 static 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
180 static 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
193 static int run_receive_hook(struct command *commands, const char *hook_name)
194 {
195 static char buf[sizeof(commands->old_sha1) * 2 + PATH_MAX + 4];
196 struct command *cmd;
197 struct child_process proc;
198 struct async muxer;
199 const char *argv[2];
200 int have_input = 0, code;
201
202 for (cmd = commands; !have_input && cmd; cmd = cmd->next) {
203 if (!cmd->error_string)
204 have_input = 1;
205 }
206
207 if (!have_input || access(hook_name, X_OK) < 0)
208 return 0;
209
210 argv[0] = hook_name;
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
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
228 code = start_command(&proc);
229 if (code) {
230 if (use_sideband)
231 finish_async(&muxer);
232 return code;
233 }
234
235 for (cmd = commands; cmd; cmd = cmd->next) {
236 if (!cmd->error_string) {
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;
243 }
244 }
245 close(proc.in);
246 if (use_sideband)
247 finish_async(&muxer);
248 return finish_command(&proc);
249 }
250
251 static int run_update_hook(struct command *cmd)
252 {
253 static const char update_hook[] = "hooks/update";
254 const char *argv[5];
255 struct child_process proc;
256 int code;
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
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);
279 }
280
281 static int is_ref_checked_out(const char *ref)
282 {
283 if (is_bare_repository())
284 return 0;
285
286 if (!head_name)
287 return 0;
288 return !strcmp(head_name, ref);
289 }
290
291 static 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.",
296 "",
297 "You can set 'receive.denyCurrentBranch' configuration variable to",
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.",
302 "",
303 "To squelch this message and still keep the default behaviour, set",
304 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
305 };
306
307 static void refuse_unconfigured_deny(void)
308 {
309 int i;
310 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
311 rp_error("%s", refuse_unconfigured_deny_msg[i]);
312 }
313
314 static 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.",
317 "",
318 "You can set 'receive.denyDeleteCurrent' configuration variable to",
319 "'warn' or 'ignore' in the remote repository to allow deleting the",
320 "current branch, with or without a warning message.",
321 "",
322 "To squelch this message, you can set it to 'refuse'."
323 };
324
325 static void refuse_unconfigured_deny_delete_current(void)
326 {
327 int i;
328 for (i = 0;
329 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
330 i++)
331 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
332 }
333
334 static const char *update(struct command *cmd)
335 {
336 const char *name = cmd->ref_name;
337 unsigned char *old_sha1 = cmd->old_sha1;
338 unsigned char *new_sha1 = cmd->new_sha1;
339 struct ref_lock *lock;
340
341 /* only refs/... are allowed */
342 if (prefixcmp(name, "refs/") || check_ref_format(name + 5)) {
343 rp_error("refusing to create funny ref '%s' remotely", name);
344 return "funny refname";
345 }
346
347 if (is_ref_checked_out(name)) {
348 switch (deny_current_branch) {
349 case DENY_IGNORE:
350 break;
351 case DENY_WARN:
352 rp_warning("updating the current branch");
353 break;
354 case DENY_REFUSE:
355 case DENY_UNCONFIGURED:
356 rp_error("refusing to update checked out branch: %s", name);
357 if (deny_current_branch == DENY_UNCONFIGURED)
358 refuse_unconfigured_deny();
359 return "branch is currently checked out";
360 }
361 }
362
363 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
364 error("unpack should have generated %s, "
365 "but I can't find it!", sha1_to_hex(new_sha1));
366 return "bad pack";
367 }
368
369 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
370 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
371 rp_error("denying ref deletion for %s", name);
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:
380 rp_warning("deleting the current branch");
381 break;
382 case DENY_REFUSE:
383 case DENY_UNCONFIGURED:
384 if (deny_delete_current == DENY_UNCONFIGURED)
385 refuse_unconfigured_deny_delete_current();
386 rp_error("refusing to delete the current branch: %s", name);
387 return "deletion of the current branch prohibited";
388 }
389 }
390 }
391
392 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
393 !is_null_sha1(old_sha1) &&
394 !prefixcmp(name, "refs/heads/")) {
395 struct object *old_object, *new_object;
396 struct commit *old_commit, *new_commit;
397 struct commit_list *bases, *ent;
398
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;
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))
413 break;
414 free_commit_list(bases);
415 if (!ent) {
416 rp_error("denying non-fast-forward %s"
417 " (you should pull first)", name);
418 return "non-fast-forward";
419 }
420 }
421 if (run_update_hook(cmd)) {
422 rp_error("hook declined to update %s", name);
423 return "hook declined";
424 }
425
426 if (is_null_sha1(new_sha1)) {
427 if (!parse_object(old_sha1)) {
428 rp_warning("Allowing deletion of corrupt ref.");
429 old_sha1 = NULL;
430 }
431 if (delete_ref(name, old_sha1, 0)) {
432 rp_error("failed to delete %s", name);
433 return "failed to delete";
434 }
435 return NULL; /* good */
436 }
437 else {
438 lock = lock_any_ref_for_update(name, old_sha1, 0);
439 if (!lock) {
440 rp_error("failed to lock %s", name);
441 return "failed to lock";
442 }
443 if (write_ref_sha1(lock, new_sha1, "push")) {
444 return "failed to write"; /* error() already called */
445 }
446 return NULL; /* good */
447 }
448 }
449
450 static char update_post_hook[] = "hooks/post-update";
451
452 static void run_update_post_hook(struct command *commands)
453 {
454 struct command *cmd;
455 int argc;
456 const char **argv;
457 struct child_process proc;
458
459 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
460 if (cmd->error_string)
461 continue;
462 argc++;
463 }
464 if (!argc || access(update_post_hook, X_OK) < 0)
465 return;
466 argv = xmalloc(sizeof(*argv) * (2 + argc));
467 argv[0] = update_post_hook;
468
469 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
470 char *p;
471 if (cmd->error_string)
472 continue;
473 p = xmalloc(strlen(cmd->ref_name) + 1);
474 strcpy(p, cmd->ref_name);
475 argv[argc] = p;
476 argc++;
477 }
478 argv[argc] = NULL;
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 }
491 }
492
493 static 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
506 if ((item = string_list_lookup(list, dst_name)) == NULL)
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));
520 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
521 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
522 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
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
532 static void check_aliased_updates(struct command *commands)
533 {
534 struct command *cmd;
535 struct string_list ref_list = STRING_LIST_INIT_NODUP;
536
537 for (cmd = commands; cmd; cmd = cmd->next) {
538 struct string_list_item *item =
539 string_list_append(&ref_list, cmd->ref_name);
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
550 static 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
562 static 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
575 static 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
587 static void execute_commands(struct command *commands, const char *unpacker_error)
588 {
589 struct command *cmd;
590 unsigned char sha1[20];
591
592 if (unpacker_error) {
593 for (cmd = commands; cmd; cmd = cmd->next)
594 cmd->error_string = "n/a (unpacker error)";
595 return;
596 }
597
598 cmd = commands;
599 if (check_everything_connected(iterate_receive_command_list,
600 0, &cmd))
601 set_connectivity_errors(commands);
602
603 if (run_receive_hook(commands, pre_receive_hook)) {
604 for (cmd = commands; cmd; cmd = cmd->next)
605 cmd->error_string = "pre-receive hook declined";
606 return;
607 }
608
609 check_aliased_updates(commands);
610
611 head_name = resolve_ref("HEAD", sha1, 0, NULL);
612
613 for (cmd = commands; cmd; cmd = cmd->next)
614 if (!cmd->skip_update)
615 cmd->error_string = update(cmd);
616 }
617
618 static struct command *read_head_info(void)
619 {
620 struct command *commands = NULL;
621 struct command **p = &commands;
622 for (;;) {
623 static char line[1000];
624 unsigned char old_sha1[20], new_sha1[20];
625 struct command *cmd;
626 char *refname;
627 int len, reflen;
628
629 len = packet_read_line(0, line, sizeof(line));
630 if (!len)
631 break;
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))
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;
647 if (strstr(refname + reflen + 1, "side-band-64k"))
648 use_sideband = LARGE_PACKET_MAX;
649 }
650 cmd = xcalloc(1, sizeof(struct command) + len - 80);
651 hashcpy(cmd->old_sha1, old_sha1);
652 hashcpy(cmd->new_sha1, new_sha1);
653 memcpy(cmd->ref_name, line + 82, len - 81);
654 *p = cmd;
655 p = &cmd->next;
656 }
657 return commands;
658 }
659
660 static const char *parse_pack_header(struct pack_header *hdr)
661 {
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:
667 return "protocol error (pack signature mismatch detected)";
668
669 case PH_ERROR_PROTOCOL:
670 return "protocol error (pack version unsupported)";
671
672 default:
673 return "unknown error in parse_pack_header";
674
675 case 0:
676 return NULL;
677 }
678 }
679
680 static const char *pack_lockfile;
681
682 static const char *unpack(void)
683 {
684 struct pack_header hdr;
685 const char *hdr_err;
686 char hdr_arg[38];
687
688 hdr_err = parse_pack_header(&hdr);
689 if (hdr_err)
690 return hdr_err;
691 snprintf(hdr_arg, sizeof(hdr_arg),
692 "--pack_header=%"PRIu32",%"PRIu32,
693 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
694
695 if (ntohl(hdr.hdr_entries) < unpack_limit) {
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;
703 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
704 if (!code)
705 return NULL;
706 return "unpack-objects abnormal exit";
707 } else {
708 const char *keeper[7];
709 int s, status, i = 0;
710 char keep_arg[256];
711 struct child_process ip;
712
713 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
714 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
715 strcpy(keep_arg + s, "localhost");
716
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;
725 memset(&ip, 0, sizeof(ip));
726 ip.argv = keeper;
727 ip.out = -1;
728 ip.git_cmd = 1;
729 status = start_command(&ip);
730 if (status) {
731 return "index-pack fork failed";
732 }
733 pack_lockfile = index_pack_lockfile(ip.out);
734 close(ip.out);
735 status = finish_command(&ip);
736 if (!status) {
737 reprepare_packed_git();
738 return NULL;
739 }
740 return "index-pack abnormal exit";
741 }
742 }
743
744 static void report(struct command *commands, const char *unpack_status)
745 {
746 struct command *cmd;
747 struct strbuf buf = STRBUF_INIT;
748
749 packet_buf_write(&buf, "unpack %s\n",
750 unpack_status ? unpack_status : "ok");
751 for (cmd = commands; cmd; cmd = cmd->next) {
752 if (!cmd->error_string)
753 packet_buf_write(&buf, "ok %s\n",
754 cmd->ref_name);
755 else
756 packet_buf_write(&buf, "ng %s %s\n",
757 cmd->ref_name, cmd->error_string);
758 }
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);
766 }
767
768 static int delete_only(struct command *commands)
769 {
770 struct command *cmd;
771 for (cmd = commands; cmd; cmd = cmd->next) {
772 if (!is_null_sha1(cmd->new_sha1))
773 return 0;
774 }
775 return 1;
776 }
777
778 static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
779 {
780 add_extra_ref(".have", sha1, 0);
781 }
782
783 static 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);
787 }
788
789 static void add_alternate_refs(void)
790 {
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);
795 }
796
797 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
798 {
799 int advertise_refs = 0;
800 int stateless_rpc = 0;
801 int i;
802 char *dir = NULL;
803 struct command *commands;
804
805 packet_trace_identity("receive-pack");
806
807 argv++;
808 for (i = 1; i < argc; i++) {
809 const char *arg = *argv++;
810
811 if (*arg == '-') {
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
821 usage(receive_pack_usage);
822 }
823 if (dir)
824 usage(receive_pack_usage);
825 dir = xstrdup(arg);
826 }
827 if (!dir)
828 usage(receive_pack_usage);
829
830 setup_path();
831
832 if (!enter_repo(dir, 0))
833 die("'%s' does not appear to be a git repository", dir);
834
835 if (is_repository_shallow())
836 die("attempt to push into a shallow repository");
837
838 git_config(receive_pack_config, NULL);
839
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
845 if (advertise_refs || !stateless_rpc) {
846 add_alternate_refs();
847 write_head_info();
848 clear_extra_refs();
849
850 /* EOF */
851 packet_flush(1);
852 }
853 if (advertise_refs)
854 return 0;
855
856 if ((commands = read_head_info()) != NULL) {
857 const char *unpack_status = NULL;
858
859 if (!delete_only(commands))
860 unpack_status = unpack();
861 execute_commands(commands, unpack_status);
862 if (pack_lockfile)
863 unlink_or_warn(pack_lockfile);
864 if (report_status)
865 report(commands, unpack_status);
866 run_receive_hook(commands, post_receive_hook);
867 run_update_post_hook(commands);
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);
876 }
877 if (use_sideband)
878 packet_flush(1);
879 return 0;
880 }