6 #include "run-command.h"
11 #include "transport.h"
12 #include "string-list.h"
13 #include "sha1-array.h"
15 static const char receive_pack_usage
[] = "git receive-pack <git-dir>";
26 static int deny_deletes
;
27 static int deny_non_fast_forwards
;
28 static enum deny_action deny_current_branch
= DENY_UNCONFIGURED
;
29 static enum deny_action deny_delete_current
= DENY_UNCONFIGURED
;
30 static int receive_fsck_objects
;
31 static int receive_unpack_limit
= -1;
32 static int transfer_unpack_limit
= -1;
33 static int unpack_limit
= 100;
34 static int report_status
;
35 static int use_sideband
;
36 static int prefer_ofs_delta
= 1;
37 static int auto_update_server_info
;
38 static int auto_gc
= 1;
39 static const char *head_name
;
40 static int sent_capabilities
;
42 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
45 if (!strcasecmp(value
, "ignore"))
47 if (!strcasecmp(value
, "warn"))
49 if (!strcasecmp(value
, "refuse"))
52 if (git_config_bool(var
, value
))
57 static int receive_pack_config(const char *var
, const char *value
, void *cb
)
59 if (strcmp(var
, "receive.denydeletes") == 0) {
60 deny_deletes
= git_config_bool(var
, value
);
64 if (strcmp(var
, "receive.denynonfastforwards") == 0) {
65 deny_non_fast_forwards
= git_config_bool(var
, value
);
69 if (strcmp(var
, "receive.unpacklimit") == 0) {
70 receive_unpack_limit
= git_config_int(var
, value
);
74 if (strcmp(var
, "transfer.unpacklimit") == 0) {
75 transfer_unpack_limit
= git_config_int(var
, value
);
79 if (strcmp(var
, "receive.fsckobjects") == 0) {
80 receive_fsck_objects
= git_config_bool(var
, value
);
84 if (!strcmp(var
, "receive.denycurrentbranch")) {
85 if (value
&& !strcasecmp(value
, "updateinstead"))
86 deny_current_branch
= DENY_UPDATE_INSTEAD
;
87 else if (value
&& !strcasecmp(value
, "detachinstead"))
88 deny_current_branch
= DENY_DETACH_INSTEAD
;
90 deny_current_branch
= parse_deny_action(var
, value
);
94 if (strcmp(var
, "receive.denydeletecurrent") == 0) {
95 deny_delete_current
= parse_deny_action(var
, value
);
99 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
100 prefer_ofs_delta
= git_config_bool(var
, value
);
104 if (strcmp(var
, "receive.updateserverinfo") == 0) {
105 auto_update_server_info
= git_config_bool(var
, value
);
109 if (strcmp(var
, "receive.autogc") == 0) {
110 auto_gc
= git_config_bool(var
, value
);
114 return git_default_config(var
, value
, cb
);
117 static int show_ref(const char *path
, const unsigned char *sha1
, int flag
, void *cb_data
)
119 if (sent_capabilities
)
120 packet_write(1, "%s %s\n", sha1_to_hex(sha1
), path
);
122 packet_write(1, "%s %s%c%s%s\n",
123 sha1_to_hex(sha1
), path
, 0,
124 " report-status delete-refs side-band-64k",
125 prefer_ofs_delta
? " ofs-delta" : "");
126 sent_capabilities
= 1;
130 static int show_ref_cb(const char *path
, const unsigned char *sha1
, int flag
, void *cb_data
)
132 path
= strip_namespace(path
);
134 * Advertise refs outside our current namespace as ".have"
135 * refs, so that the client can use them to minimize data
136 * transfer but will otherwise ignore them. This happens to
137 * cover ".have" that are thrown in by add_one_alternate_ref()
138 * to mark histories that are complete in our alternates as
143 return show_ref(path
, sha1
, flag
, cb_data
);
146 static void write_head_info(void)
148 for_each_ref(show_ref_cb
, NULL
);
149 if (!sent_capabilities
)
150 show_ref("capabilities^{}", null_sha1
, 0, NULL
);
155 struct command
*next
;
156 const char *error_string
;
157 unsigned int skip_update
;
158 unsigned char old_sha1
[20];
159 unsigned char new_sha1
[20];
160 char ref_name
[FLEX_ARRAY
]; /* more */
163 static const char pre_receive_hook
[] = "hooks/pre-receive";
164 static const char post_receive_hook
[] = "hooks/post-receive";
166 static void rp_error(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
167 static void rp_warning(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
169 static void report_message(const char *prefix
, const char *err
, va_list params
)
171 int sz
= strlen(prefix
);
174 strncpy(msg
, prefix
, sz
);
175 sz
+= vsnprintf(msg
+ sz
, sizeof(msg
) - sz
, err
, params
);
176 if (sz
> (sizeof(msg
) - 1))
177 sz
= sizeof(msg
) - 1;
181 send_sideband(1, 2, msg
, sz
, use_sideband
);
186 static void rp_warning(const char *err
, ...)
189 va_start(params
, err
);
190 report_message("warning: ", err
, params
);
194 static void rp_error(const char *err
, ...)
197 va_start(params
, err
);
198 report_message("error: ", err
, params
);
202 static int copy_to_sideband(int in
, int out
, void *arg
)
206 ssize_t sz
= xread(in
, data
, sizeof(data
));
209 send_sideband(1, 2, data
, sz
, use_sideband
);
215 static int run_receive_hook(struct command
*commands
, const char *hook_name
)
217 static char buf
[sizeof(commands
->old_sha1
) * 2 + PATH_MAX
+ 4];
219 struct child_process proc
;
222 int have_input
= 0, code
;
224 for (cmd
= commands
; !have_input
&& cmd
; cmd
= cmd
->next
) {
225 if (!cmd
->error_string
)
229 if (!have_input
|| access(hook_name
, X_OK
) < 0)
235 memset(&proc
, 0, sizeof(proc
));
238 proc
.stdout_to_stderr
= 1;
241 memset(&muxer
, 0, sizeof(muxer
));
242 muxer
.proc
= copy_to_sideband
;
244 code
= start_async(&muxer
);
250 code
= start_command(&proc
);
253 finish_async(&muxer
);
257 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
258 if (!cmd
->error_string
) {
259 size_t n
= snprintf(buf
, sizeof(buf
), "%s %s %s\n",
260 sha1_to_hex(cmd
->old_sha1
),
261 sha1_to_hex(cmd
->new_sha1
),
263 if (write_in_full(proc
.in
, buf
, n
) != n
)
269 finish_async(&muxer
);
270 return finish_command(&proc
);
273 static int run_update_hook(struct command
*cmd
)
275 static const char update_hook
[] = "hooks/update";
277 struct child_process proc
;
280 if (access(update_hook
, X_OK
) < 0)
283 argv
[0] = update_hook
;
284 argv
[1] = cmd
->ref_name
;
285 argv
[2] = sha1_to_hex(cmd
->old_sha1
);
286 argv
[3] = sha1_to_hex(cmd
->new_sha1
);
289 memset(&proc
, 0, sizeof(proc
));
291 proc
.stdout_to_stderr
= 1;
292 proc
.err
= use_sideband
? -1 : 0;
295 code
= start_command(&proc
);
299 copy_to_sideband(proc
.err
, -1, NULL
);
300 return finish_command(&proc
);
303 static int is_ref_checked_out(const char *ref
)
305 if (is_bare_repository())
310 return !strcmp(head_name
, ref
);
313 static char *refuse_unconfigured_deny_msg
[] = {
314 "By default, updating the current branch in a non-bare repository",
315 "is denied, because it will make the index and work tree inconsistent",
316 "with what you pushed, and will require 'git reset --hard' to match",
317 "the work tree to HEAD.",
319 "You can set 'receive.denyCurrentBranch' configuration variable to",
320 "'ignore' or 'warn' in the remote repository to allow pushing into",
321 "its current branch; however, this is not recommended unless you",
322 "arranged to update its work tree to match what you pushed in some",
325 "To squelch this message and still keep the default behaviour, set",
326 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
329 static void refuse_unconfigured_deny(void)
332 for (i
= 0; i
< ARRAY_SIZE(refuse_unconfigured_deny_msg
); i
++)
333 rp_error("%s", refuse_unconfigured_deny_msg
[i
]);
336 static char *refuse_unconfigured_deny_delete_current_msg
[] = {
337 "By default, deleting the current branch is denied, because the next",
338 "'git clone' won't result in any file checked out, causing confusion.",
340 "You can set 'receive.denyDeleteCurrent' configuration variable to",
341 "'warn' or 'ignore' in the remote repository to allow deleting the",
342 "current branch, with or without a warning message.",
344 "To squelch this message, you can set it to 'refuse'."
347 static void refuse_unconfigured_deny_delete_current(void)
351 i
< ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg
);
353 rp_error("%s", refuse_unconfigured_deny_delete_current_msg
[i
]);
356 static void merge_worktree(unsigned char *sha1
)
358 const char *update_refresh
[] = {
359 "update-index", "--refresh", NULL
361 const char *read_tree
[] = {
362 "read-tree", "-u", "-m", sha1_to_hex(sha1
), NULL
364 struct child_process child
;
365 struct strbuf git_env
= STRBUF_INIT
;
368 if (is_bare_repository())
369 die ("denyCurrentBranch = updateInstead needs a worktree");
371 strbuf_addf(&git_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
372 env
[0] = git_env
.buf
;
375 memset(&child
, 0, sizeof(child
));
376 child
.argv
= update_refresh
;
378 child
.dir
= git_work_tree_cfg
? git_work_tree_cfg
: "..";
379 child
.stdout_to_stderr
= 1;
381 if (run_command(&child
))
382 die ("Could not refresh the index");
384 child
.argv
= read_tree
;
387 child
.stdout_to_stderr
= 0;
388 if (run_command(&child
))
389 die ("Could not merge working tree with new HEAD. Good luck.");
391 strbuf_release(&git_env
);
394 static const char *update(struct command
*cmd
)
396 const char *name
= cmd
->ref_name
;
397 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
398 const char *namespaced_name
;
399 unsigned char *old_sha1
= cmd
->old_sha1
;
400 unsigned char *new_sha1
= cmd
->new_sha1
;
401 struct ref_lock
*lock
;
403 /* only refs/... are allowed */
404 if (prefixcmp(name
, "refs/") || check_ref_format(name
+ 5)) {
405 rp_error("refusing to create funny ref '%s' remotely", name
);
406 return "funny refname";
409 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
410 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
412 if (is_ref_checked_out(namespaced_name
)) {
413 switch (deny_current_branch
) {
417 rp_warning("updating the current branch");
420 case DENY_UNCONFIGURED
:
421 rp_error("refusing to update checked out branch: %s", name
);
422 if (deny_current_branch
== DENY_UNCONFIGURED
)
423 refuse_unconfigured_deny();
424 return "branch is currently checked out";
425 case DENY_UPDATE_INSTEAD
:
426 merge_worktree(new_sha1
);
428 case DENY_DETACH_INSTEAD
:
429 update_ref("push into current branch (detach)", "HEAD",
430 old_sha1
, NULL
, REF_NODEREF
, DIE_ON_ERR
);
435 if (!is_null_sha1(new_sha1
) && !has_sha1_file(new_sha1
)) {
436 error("unpack should have generated %s, "
437 "but I can't find it!", sha1_to_hex(new_sha1
));
441 if (!is_null_sha1(old_sha1
) && is_null_sha1(new_sha1
)) {
442 if (deny_deletes
&& !prefixcmp(name
, "refs/heads/")) {
443 rp_error("denying ref deletion for %s", name
);
444 return "deletion prohibited";
447 if (!strcmp(namespaced_name
, head_name
)) {
448 switch (deny_delete_current
) {
452 rp_warning("deleting the current branch");
455 case DENY_UNCONFIGURED
:
456 if (deny_delete_current
== DENY_UNCONFIGURED
)
457 refuse_unconfigured_deny_delete_current();
458 rp_error("refusing to delete the current branch: %s", name
);
459 return "deletion of the current branch prohibited";
461 die ("Invalid denyDeleteCurrent setting");
466 if (deny_non_fast_forwards
&& !is_null_sha1(new_sha1
) &&
467 !is_null_sha1(old_sha1
) &&
468 !prefixcmp(name
, "refs/heads/")) {
469 struct object
*old_object
, *new_object
;
470 struct commit
*old_commit
, *new_commit
;
471 struct commit_list
*bases
, *ent
;
473 old_object
= parse_object(old_sha1
);
474 new_object
= parse_object(new_sha1
);
476 if (!old_object
|| !new_object
||
477 old_object
->type
!= OBJ_COMMIT
||
478 new_object
->type
!= OBJ_COMMIT
) {
479 error("bad sha1 objects for %s", name
);
482 old_commit
= (struct commit
*)old_object
;
483 new_commit
= (struct commit
*)new_object
;
484 bases
= get_merge_bases(old_commit
, new_commit
, 1);
485 for (ent
= bases
; ent
; ent
= ent
->next
)
486 if (!hashcmp(old_sha1
, ent
->item
->object
.sha1
))
488 free_commit_list(bases
);
490 rp_error("denying non-fast-forward %s"
491 " (you should pull first)", name
);
492 return "non-fast-forward";
495 if (run_update_hook(cmd
)) {
496 rp_error("hook declined to update %s", name
);
497 return "hook declined";
500 if (is_null_sha1(new_sha1
)) {
501 if (!parse_object(old_sha1
)) {
502 rp_warning("Allowing deletion of corrupt ref.");
505 if (delete_ref(namespaced_name
, old_sha1
, 0)) {
506 rp_error("failed to delete %s", name
);
507 return "failed to delete";
509 return NULL
; /* good */
512 lock
= lock_any_ref_for_update(namespaced_name
, old_sha1
, 0);
514 rp_error("failed to lock %s", name
);
515 return "failed to lock";
517 if (write_ref_sha1(lock
, new_sha1
, "push")) {
518 return "failed to write"; /* error() already called */
520 return NULL
; /* good */
524 static char update_post_hook
[] = "hooks/post-update";
526 static void run_update_post_hook(struct command
*commands
)
531 struct child_process proc
;
533 for (argc
= 0, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
534 if (cmd
->error_string
)
538 if (!argc
|| access(update_post_hook
, X_OK
) < 0)
540 argv
= xmalloc(sizeof(*argv
) * (2 + argc
));
541 argv
[0] = update_post_hook
;
543 for (argc
= 1, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
545 if (cmd
->error_string
)
547 p
= xmalloc(strlen(cmd
->ref_name
) + 1);
548 strcpy(p
, cmd
->ref_name
);
554 memset(&proc
, 0, sizeof(proc
));
556 proc
.stdout_to_stderr
= 1;
557 proc
.err
= use_sideband
? -1 : 0;
560 if (!start_command(&proc
)) {
562 copy_to_sideband(proc
.err
, -1, NULL
);
563 finish_command(&proc
);
567 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
569 struct strbuf buf
= STRBUF_INIT
;
570 const char *dst_name
;
571 struct string_list_item
*item
;
572 struct command
*dst_cmd
;
573 unsigned char sha1
[20];
574 char cmd_oldh
[41], cmd_newh
[41], dst_oldh
[41], dst_newh
[41];
577 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
578 dst_name
= resolve_ref(buf
.buf
, sha1
, 0, &flag
);
579 strbuf_release(&buf
);
581 if (!(flag
& REF_ISSYMREF
))
584 dst_name
= strip_namespace(dst_name
);
586 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
587 cmd
->skip_update
= 1;
588 cmd
->error_string
= "broken symref";
592 if ((item
= string_list_lookup(list
, dst_name
)) == NULL
)
595 cmd
->skip_update
= 1;
597 dst_cmd
= (struct command
*) item
->util
;
599 if (!hashcmp(cmd
->old_sha1
, dst_cmd
->old_sha1
) &&
600 !hashcmp(cmd
->new_sha1
, dst_cmd
->new_sha1
))
603 dst_cmd
->skip_update
= 1;
605 strcpy(cmd_oldh
, find_unique_abbrev(cmd
->old_sha1
, DEFAULT_ABBREV
));
606 strcpy(cmd_newh
, find_unique_abbrev(cmd
->new_sha1
, DEFAULT_ABBREV
));
607 strcpy(dst_oldh
, find_unique_abbrev(dst_cmd
->old_sha1
, DEFAULT_ABBREV
));
608 strcpy(dst_newh
, find_unique_abbrev(dst_cmd
->new_sha1
, DEFAULT_ABBREV
));
609 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
610 " its target '%s' (%s..%s)",
611 cmd
->ref_name
, cmd_oldh
, cmd_newh
,
612 dst_cmd
->ref_name
, dst_oldh
, dst_newh
);
614 cmd
->error_string
= dst_cmd
->error_string
=
615 "inconsistent aliased update";
618 static void check_aliased_updates(struct command
*commands
)
621 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
623 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
624 struct string_list_item
*item
=
625 string_list_append(&ref_list
, cmd
->ref_name
);
626 item
->util
= (void *)cmd
;
628 sort_string_list(&ref_list
);
630 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
631 check_aliased_update(cmd
, &ref_list
);
633 string_list_clear(&ref_list
, 0);
636 static void execute_commands(struct command
*commands
, const char *unpacker_error
)
639 unsigned char sha1
[20];
641 if (unpacker_error
) {
642 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
643 cmd
->error_string
= "n/a (unpacker error)";
647 if (run_receive_hook(commands
, pre_receive_hook
)) {
648 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
649 cmd
->error_string
= "pre-receive hook declined";
653 check_aliased_updates(commands
);
655 head_name
= resolve_ref("HEAD", sha1
, 0, NULL
);
657 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
658 if (!cmd
->skip_update
)
659 cmd
->error_string
= update(cmd
);
662 static struct command
*read_head_info(void)
664 struct command
*commands
= NULL
;
665 struct command
**p
= &commands
;
667 static char line
[1000];
668 unsigned char old_sha1
[20], new_sha1
[20];
673 len
= packet_read_line(0, line
, sizeof(line
));
676 if (line
[len
-1] == '\n')
681 get_sha1_hex(line
, old_sha1
) ||
682 get_sha1_hex(line
+ 41, new_sha1
))
683 die("protocol error: expected old/new/ref, got '%s'",
687 reflen
= strlen(refname
);
688 if (reflen
+ 82 < len
) {
689 if (strstr(refname
+ reflen
+ 1, "report-status"))
691 if (strstr(refname
+ reflen
+ 1, "side-band-64k"))
692 use_sideband
= LARGE_PACKET_MAX
;
694 cmd
= xcalloc(1, sizeof(struct command
) + len
- 80);
695 hashcpy(cmd
->old_sha1
, old_sha1
);
696 hashcpy(cmd
->new_sha1
, new_sha1
);
697 memcpy(cmd
->ref_name
, line
+ 82, len
- 81);
704 static const char *parse_pack_header(struct pack_header
*hdr
)
706 switch (read_pack_header(0, hdr
)) {
708 return "eof before pack header was fully read";
710 case PH_ERROR_PACK_SIGNATURE
:
711 return "protocol error (pack signature mismatch detected)";
713 case PH_ERROR_PROTOCOL
:
714 return "protocol error (pack version unsupported)";
717 return "unknown error in parse_pack_header";
724 static const char *pack_lockfile
;
726 static const char *unpack(int quiet
)
728 struct pack_header hdr
;
732 hdr_err
= parse_pack_header(&hdr
);
735 snprintf(hdr_arg
, sizeof(hdr_arg
),
736 "--pack_header=%"PRIu32
",%"PRIu32
,
737 ntohl(hdr
.hdr_version
), ntohl(hdr
.hdr_entries
));
739 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
741 const char *unpacker
[4];
742 unpacker
[i
++] = "unpack-objects";
744 unpacker
[i
++] = "-q";
745 if (receive_fsck_objects
)
746 unpacker
[i
++] = "--strict";
747 unpacker
[i
++] = hdr_arg
;
748 unpacker
[i
++] = NULL
;
749 code
= run_command_v_opt(unpacker
, RUN_GIT_CMD
);
752 return "unpack-objects abnormal exit";
754 const char *keeper
[7];
755 int s
, status
, i
= 0;
757 struct child_process ip
;
759 s
= sprintf(keep_arg
, "--keep=receive-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
760 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
761 strcpy(keep_arg
+ s
, "localhost");
763 keeper
[i
++] = "index-pack";
764 keeper
[i
++] = "--stdin";
765 if (receive_fsck_objects
)
766 keeper
[i
++] = "--strict";
767 keeper
[i
++] = "--fix-thin";
768 keeper
[i
++] = hdr_arg
;
769 keeper
[i
++] = keep_arg
;
771 memset(&ip
, 0, sizeof(ip
));
775 status
= start_command(&ip
);
777 return "index-pack fork failed";
779 pack_lockfile
= index_pack_lockfile(ip
.out
);
781 status
= finish_command(&ip
);
783 reprepare_packed_git();
786 return "index-pack abnormal exit";
790 static void report(struct command
*commands
, const char *unpack_status
)
793 struct strbuf buf
= STRBUF_INIT
;
795 packet_buf_write(&buf
, "unpack %s\n",
796 unpack_status
? unpack_status
: "ok");
797 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
798 if (!cmd
->error_string
)
799 packet_buf_write(&buf
, "ok %s\n",
802 packet_buf_write(&buf
, "ng %s %s\n",
803 cmd
->ref_name
, cmd
->error_string
);
805 packet_buf_flush(&buf
);
808 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
810 safe_write(1, buf
.buf
, buf
.len
);
811 strbuf_release(&buf
);
814 static int delete_only(struct command
*commands
)
817 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
818 if (!is_null_sha1(cmd
->new_sha1
))
824 static void add_one_alternate_sha1(const unsigned char sha1
[20], void *unused
)
826 add_extra_ref(".have", sha1
, 0);
829 static void collect_one_alternate_ref(const struct ref
*ref
, void *data
)
831 struct sha1_array
*sa
= data
;
832 sha1_array_append(sa
, ref
->old_sha1
);
835 static void add_alternate_refs(void)
837 struct sha1_array sa
= SHA1_ARRAY_INIT
;
838 for_each_alternate_ref(collect_one_alternate_ref
, &sa
);
839 sha1_array_for_each_unique(&sa
, add_one_alternate_sha1
, NULL
);
840 sha1_array_clear(&sa
);
843 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
846 int advertise_refs
= 0;
847 int stateless_rpc
= 0;
850 struct command
*commands
;
852 packet_trace_identity("receive-pack");
855 for (i
= 1; i
< argc
; i
++) {
856 const char *arg
= *argv
++;
859 if (!strcmp(arg
, "--quiet")) {
864 if (!strcmp(arg
, "--advertise-refs")) {
868 if (!strcmp(arg
, "--stateless-rpc")) {
873 usage(receive_pack_usage
);
876 usage(receive_pack_usage
);
880 usage(receive_pack_usage
);
884 if (!enter_repo(dir
, 0))
885 die("'%s' does not appear to be a git repository", dir
);
887 if (is_repository_shallow())
888 die("attempt to push into a shallow repository");
890 git_config(receive_pack_config
, NULL
);
892 if (0 <= transfer_unpack_limit
)
893 unpack_limit
= transfer_unpack_limit
;
894 else if (0 <= receive_unpack_limit
)
895 unpack_limit
= receive_unpack_limit
;
897 if (advertise_refs
|| !stateless_rpc
) {
898 add_alternate_refs();
908 if ((commands
= read_head_info()) != NULL
) {
909 const char *unpack_status
= NULL
;
911 if (!delete_only(commands
))
912 unpack_status
= unpack(quiet
);
913 execute_commands(commands
, unpack_status
);
915 unlink_or_warn(pack_lockfile
);
917 report(commands
, unpack_status
);
918 run_receive_hook(commands
, post_receive_hook
);
919 run_update_post_hook(commands
);
921 const char *argv_gc_auto
[] = {
922 "gc", "--auto", "--quiet", NULL
,
924 run_command_v_opt(argv_gc_auto
, RUN_GIT_CMD
);
926 if (auto_update_server_info
)
927 update_server_info(0);