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