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