6 #include "run-command.h"
11 #include "transport.h"
12 #include "string-list.h"
13 #include "sha1-array.h"
14 #include "connected.h"
16 static const char receive_pack_usage
[] = "git receive-pack <git-dir>";
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
= -1;
30 static int transfer_fsck_objects
= -1;
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
, "transfer.fsckobjects") == 0) {
85 transfer_fsck_objects
= git_config_bool(var
, value
);
89 if (!strcmp(var
, "receive.denycurrentbranch")) {
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 typedef int (*feed_fn
)(void *, const char **, size_t *);
216 static int run_and_feed_hook(const char *hook_name
, feed_fn feed
, void *feed_state
)
218 struct child_process proc
;
223 if (access(hook_name
, X_OK
) < 0)
229 memset(&proc
, 0, sizeof(proc
));
232 proc
.stdout_to_stderr
= 1;
235 memset(&muxer
, 0, sizeof(muxer
));
236 muxer
.proc
= copy_to_sideband
;
238 code
= start_async(&muxer
);
244 code
= start_command(&proc
);
247 finish_async(&muxer
);
254 if (feed(feed_state
, &buf
, &n
))
256 if (write_in_full(proc
.in
, buf
, n
) != n
)
261 finish_async(&muxer
);
262 return finish_command(&proc
);
265 struct receive_hook_feed_state
{
270 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
272 struct receive_hook_feed_state
*state
= state_
;
273 struct command
*cmd
= state
->cmd
;
275 while (cmd
&& cmd
->error_string
)
279 strbuf_reset(&state
->buf
);
280 strbuf_addf(&state
->buf
, "%s %s %s\n",
281 sha1_to_hex(cmd
->old_sha1
), sha1_to_hex(cmd
->new_sha1
),
283 state
->cmd
= cmd
->next
;
285 *bufp
= state
->buf
.buf
;
286 *sizep
= state
->buf
.len
;
291 static int run_receive_hook(struct command
*commands
, const char *hook_name
)
293 struct receive_hook_feed_state state
;
296 strbuf_init(&state
.buf
, 0);
297 state
.cmd
= commands
;
298 if (feed_receive_hook(&state
, NULL
, NULL
))
300 state
.cmd
= commands
;
301 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
302 strbuf_release(&state
.buf
);
306 static int run_update_hook(struct command
*cmd
)
308 static const char update_hook
[] = "hooks/update";
310 struct child_process proc
;
313 if (access(update_hook
, X_OK
) < 0)
316 argv
[0] = update_hook
;
317 argv
[1] = cmd
->ref_name
;
318 argv
[2] = sha1_to_hex(cmd
->old_sha1
);
319 argv
[3] = sha1_to_hex(cmd
->new_sha1
);
322 memset(&proc
, 0, sizeof(proc
));
324 proc
.stdout_to_stderr
= 1;
325 proc
.err
= use_sideband
? -1 : 0;
328 code
= start_command(&proc
);
332 copy_to_sideband(proc
.err
, -1, NULL
);
333 return finish_command(&proc
);
336 static int is_ref_checked_out(const char *ref
)
338 if (is_bare_repository())
343 return !strcmp(head_name
, ref
);
346 static char *refuse_unconfigured_deny_msg
[] = {
347 "By default, updating the current branch in a non-bare repository",
348 "is denied, because it will make the index and work tree inconsistent",
349 "with what you pushed, and will require 'git reset --hard' to match",
350 "the work tree to HEAD.",
352 "You can set 'receive.denyCurrentBranch' configuration variable to",
353 "'ignore' or 'warn' in the remote repository to allow pushing into",
354 "its current branch; however, this is not recommended unless you",
355 "arranged to update its work tree to match what you pushed in some",
358 "To squelch this message and still keep the default behaviour, set",
359 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
362 static void refuse_unconfigured_deny(void)
365 for (i
= 0; i
< ARRAY_SIZE(refuse_unconfigured_deny_msg
); i
++)
366 rp_error("%s", refuse_unconfigured_deny_msg
[i
]);
369 static char *refuse_unconfigured_deny_delete_current_msg
[] = {
370 "By default, deleting the current branch is denied, because the next",
371 "'git clone' won't result in any file checked out, causing confusion.",
373 "You can set 'receive.denyDeleteCurrent' configuration variable to",
374 "'warn' or 'ignore' in the remote repository to allow deleting the",
375 "current branch, with or without a warning message.",
377 "To squelch this message, you can set it to 'refuse'."
380 static void refuse_unconfigured_deny_delete_current(void)
384 i
< ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg
);
386 rp_error("%s", refuse_unconfigured_deny_delete_current_msg
[i
]);
389 static const char *update(struct command
*cmd
)
391 const char *name
= cmd
->ref_name
;
392 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
393 const char *namespaced_name
;
394 unsigned char *old_sha1
= cmd
->old_sha1
;
395 unsigned char *new_sha1
= cmd
->new_sha1
;
396 struct ref_lock
*lock
;
398 /* only refs/... are allowed */
399 if (prefixcmp(name
, "refs/") || check_ref_format(name
+ 5)) {
400 rp_error("refusing to create funny ref '%s' remotely", name
);
401 return "funny refname";
404 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
405 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
407 if (is_ref_checked_out(namespaced_name
)) {
408 switch (deny_current_branch
) {
412 rp_warning("updating the current branch");
415 case DENY_UNCONFIGURED
:
416 rp_error("refusing to update checked out branch: %s", name
);
417 if (deny_current_branch
== DENY_UNCONFIGURED
)
418 refuse_unconfigured_deny();
419 return "branch is currently checked out";
423 if (!is_null_sha1(new_sha1
) && !has_sha1_file(new_sha1
)) {
424 error("unpack should have generated %s, "
425 "but I can't find it!", sha1_to_hex(new_sha1
));
429 if (!is_null_sha1(old_sha1
) && is_null_sha1(new_sha1
)) {
430 if (deny_deletes
&& !prefixcmp(name
, "refs/heads/")) {
431 rp_error("denying ref deletion for %s", name
);
432 return "deletion prohibited";
435 if (!strcmp(namespaced_name
, head_name
)) {
436 switch (deny_delete_current
) {
440 rp_warning("deleting the current branch");
443 case DENY_UNCONFIGURED
:
444 if (deny_delete_current
== DENY_UNCONFIGURED
)
445 refuse_unconfigured_deny_delete_current();
446 rp_error("refusing to delete the current branch: %s", name
);
447 return "deletion of the current branch prohibited";
452 if (deny_non_fast_forwards
&& !is_null_sha1(new_sha1
) &&
453 !is_null_sha1(old_sha1
) &&
454 !prefixcmp(name
, "refs/heads/")) {
455 struct object
*old_object
, *new_object
;
456 struct commit
*old_commit
, *new_commit
;
457 struct commit_list
*bases
, *ent
;
459 old_object
= parse_object(old_sha1
);
460 new_object
= parse_object(new_sha1
);
462 if (!old_object
|| !new_object
||
463 old_object
->type
!= OBJ_COMMIT
||
464 new_object
->type
!= OBJ_COMMIT
) {
465 error("bad sha1 objects for %s", name
);
468 old_commit
= (struct commit
*)old_object
;
469 new_commit
= (struct commit
*)new_object
;
470 bases
= get_merge_bases(old_commit
, new_commit
, 1);
471 for (ent
= bases
; ent
; ent
= ent
->next
)
472 if (!hashcmp(old_sha1
, ent
->item
->object
.sha1
))
474 free_commit_list(bases
);
476 rp_error("denying non-fast-forward %s"
477 " (you should pull first)", name
);
478 return "non-fast-forward";
481 if (run_update_hook(cmd
)) {
482 rp_error("hook declined to update %s", name
);
483 return "hook declined";
486 if (is_null_sha1(new_sha1
)) {
487 if (!parse_object(old_sha1
)) {
488 rp_warning("Allowing deletion of corrupt ref.");
491 if (delete_ref(namespaced_name
, old_sha1
, 0)) {
492 rp_error("failed to delete %s", name
);
493 return "failed to delete";
495 return NULL
; /* good */
498 lock
= lock_any_ref_for_update(namespaced_name
, old_sha1
, 0);
500 rp_error("failed to lock %s", name
);
501 return "failed to lock";
503 if (write_ref_sha1(lock
, new_sha1
, "push")) {
504 return "failed to write"; /* error() already called */
506 return NULL
; /* good */
510 static char update_post_hook
[] = "hooks/post-update";
512 static void run_update_post_hook(struct command
*commands
)
517 struct child_process proc
;
519 for (argc
= 0, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
520 if (cmd
->error_string
)
524 if (!argc
|| access(update_post_hook
, X_OK
) < 0)
526 argv
= xmalloc(sizeof(*argv
) * (2 + argc
));
527 argv
[0] = update_post_hook
;
529 for (argc
= 1, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
531 if (cmd
->error_string
)
533 p
= xmalloc(strlen(cmd
->ref_name
) + 1);
534 strcpy(p
, cmd
->ref_name
);
540 memset(&proc
, 0, sizeof(proc
));
542 proc
.stdout_to_stderr
= 1;
543 proc
.err
= use_sideband
? -1 : 0;
546 if (!start_command(&proc
)) {
548 copy_to_sideband(proc
.err
, -1, NULL
);
549 finish_command(&proc
);
553 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
555 struct strbuf buf
= STRBUF_INIT
;
556 const char *dst_name
;
557 struct string_list_item
*item
;
558 struct command
*dst_cmd
;
559 unsigned char sha1
[20];
560 char cmd_oldh
[41], cmd_newh
[41], dst_oldh
[41], dst_newh
[41];
563 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
564 dst_name
= resolve_ref(buf
.buf
, sha1
, 0, &flag
);
565 strbuf_release(&buf
);
567 if (!(flag
& REF_ISSYMREF
))
570 dst_name
= strip_namespace(dst_name
);
572 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
573 cmd
->skip_update
= 1;
574 cmd
->error_string
= "broken symref";
578 if ((item
= string_list_lookup(list
, dst_name
)) == NULL
)
581 cmd
->skip_update
= 1;
583 dst_cmd
= (struct command
*) item
->util
;
585 if (!hashcmp(cmd
->old_sha1
, dst_cmd
->old_sha1
) &&
586 !hashcmp(cmd
->new_sha1
, dst_cmd
->new_sha1
))
589 dst_cmd
->skip_update
= 1;
591 strcpy(cmd_oldh
, find_unique_abbrev(cmd
->old_sha1
, DEFAULT_ABBREV
));
592 strcpy(cmd_newh
, find_unique_abbrev(cmd
->new_sha1
, DEFAULT_ABBREV
));
593 strcpy(dst_oldh
, find_unique_abbrev(dst_cmd
->old_sha1
, DEFAULT_ABBREV
));
594 strcpy(dst_newh
, find_unique_abbrev(dst_cmd
->new_sha1
, DEFAULT_ABBREV
));
595 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
596 " its target '%s' (%s..%s)",
597 cmd
->ref_name
, cmd_oldh
, cmd_newh
,
598 dst_cmd
->ref_name
, dst_oldh
, dst_newh
);
600 cmd
->error_string
= dst_cmd
->error_string
=
601 "inconsistent aliased update";
604 static void check_aliased_updates(struct command
*commands
)
607 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
609 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
610 struct string_list_item
*item
=
611 string_list_append(&ref_list
, cmd
->ref_name
);
612 item
->util
= (void *)cmd
;
614 sort_string_list(&ref_list
);
616 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
617 check_aliased_update(cmd
, &ref_list
);
619 string_list_clear(&ref_list
, 0);
622 static int command_singleton_iterator(void *cb_data
, unsigned char sha1
[20])
624 struct command
**cmd_list
= cb_data
;
625 struct command
*cmd
= *cmd_list
;
628 return -1; /* end of list */
629 *cmd_list
= NULL
; /* this returns only one */
630 hashcpy(sha1
, cmd
->new_sha1
);
634 static void set_connectivity_errors(struct command
*commands
)
638 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
639 struct command
*singleton
= cmd
;
640 if (!check_everything_connected(command_singleton_iterator
,
643 cmd
->error_string
= "missing necessary objects";
647 static int iterate_receive_command_list(void *cb_data
, unsigned char sha1
[20])
649 struct command
**cmd_list
= cb_data
;
650 struct command
*cmd
= *cmd_list
;
653 return -1; /* end of list */
654 *cmd_list
= cmd
->next
;
655 hashcpy(sha1
, cmd
->new_sha1
);
659 static void execute_commands(struct command
*commands
, const char *unpacker_error
)
662 unsigned char sha1
[20];
664 if (unpacker_error
) {
665 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
666 cmd
->error_string
= "n/a (unpacker error)";
671 if (check_everything_connected(iterate_receive_command_list
,
673 set_connectivity_errors(commands
);
675 if (run_receive_hook(commands
, pre_receive_hook
)) {
676 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
677 cmd
->error_string
= "pre-receive hook declined";
681 check_aliased_updates(commands
);
683 head_name
= resolve_ref("HEAD", sha1
, 0, NULL
);
685 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
686 if (!cmd
->skip_update
)
687 cmd
->error_string
= update(cmd
);
690 static struct command
*read_head_info(void)
692 struct command
*commands
= NULL
;
693 struct command
**p
= &commands
;
695 static char line
[1000];
696 unsigned char old_sha1
[20], new_sha1
[20];
701 len
= packet_read_line(0, line
, sizeof(line
));
704 if (line
[len
-1] == '\n')
709 get_sha1_hex(line
, old_sha1
) ||
710 get_sha1_hex(line
+ 41, new_sha1
))
711 die("protocol error: expected old/new/ref, got '%s'",
715 reflen
= strlen(refname
);
716 if (reflen
+ 82 < len
) {
717 if (strstr(refname
+ reflen
+ 1, "report-status"))
719 if (strstr(refname
+ reflen
+ 1, "side-band-64k"))
720 use_sideband
= LARGE_PACKET_MAX
;
722 cmd
= xcalloc(1, sizeof(struct command
) + len
- 80);
723 hashcpy(cmd
->old_sha1
, old_sha1
);
724 hashcpy(cmd
->new_sha1
, new_sha1
);
725 memcpy(cmd
->ref_name
, line
+ 82, len
- 81);
732 static const char *parse_pack_header(struct pack_header
*hdr
)
734 switch (read_pack_header(0, hdr
)) {
736 return "eof before pack header was fully read";
738 case PH_ERROR_PACK_SIGNATURE
:
739 return "protocol error (pack signature mismatch detected)";
741 case PH_ERROR_PROTOCOL
:
742 return "protocol error (pack version unsupported)";
745 return "unknown error in parse_pack_header";
752 static const char *pack_lockfile
;
754 static const char *unpack(void)
756 struct pack_header hdr
;
759 int fsck_objects
= (receive_fsck_objects
>= 0
760 ? receive_fsck_objects
761 : transfer_fsck_objects
>= 0
762 ? transfer_fsck_objects
765 hdr_err
= parse_pack_header(&hdr
);
768 snprintf(hdr_arg
, sizeof(hdr_arg
),
769 "--pack_header=%"PRIu32
",%"PRIu32
,
770 ntohl(hdr
.hdr_version
), ntohl(hdr
.hdr_entries
));
772 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
774 const char *unpacker
[4];
775 unpacker
[i
++] = "unpack-objects";
777 unpacker
[i
++] = "--strict";
778 unpacker
[i
++] = hdr_arg
;
779 unpacker
[i
++] = NULL
;
780 code
= run_command_v_opt(unpacker
, RUN_GIT_CMD
);
783 return "unpack-objects abnormal exit";
785 const char *keeper
[7];
786 int s
, status
, i
= 0;
788 struct child_process ip
;
790 s
= sprintf(keep_arg
, "--keep=receive-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
791 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
792 strcpy(keep_arg
+ s
, "localhost");
794 keeper
[i
++] = "index-pack";
795 keeper
[i
++] = "--stdin";
797 keeper
[i
++] = "--strict";
798 keeper
[i
++] = "--fix-thin";
799 keeper
[i
++] = hdr_arg
;
800 keeper
[i
++] = keep_arg
;
802 memset(&ip
, 0, sizeof(ip
));
806 status
= start_command(&ip
);
808 return "index-pack fork failed";
810 pack_lockfile
= index_pack_lockfile(ip
.out
);
812 status
= finish_command(&ip
);
814 reprepare_packed_git();
817 return "index-pack abnormal exit";
821 static void report(struct command
*commands
, const char *unpack_status
)
824 struct strbuf buf
= STRBUF_INIT
;
826 packet_buf_write(&buf
, "unpack %s\n",
827 unpack_status
? unpack_status
: "ok");
828 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
829 if (!cmd
->error_string
)
830 packet_buf_write(&buf
, "ok %s\n",
833 packet_buf_write(&buf
, "ng %s %s\n",
834 cmd
->ref_name
, cmd
->error_string
);
836 packet_buf_flush(&buf
);
839 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
841 safe_write(1, buf
.buf
, buf
.len
);
842 strbuf_release(&buf
);
845 static int delete_only(struct command
*commands
)
848 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
849 if (!is_null_sha1(cmd
->new_sha1
))
855 static void add_one_alternate_sha1(const unsigned char sha1
[20], void *unused
)
857 add_extra_ref(".have", sha1
, 0);
860 static void collect_one_alternate_ref(const struct ref
*ref
, void *data
)
862 struct sha1_array
*sa
= data
;
863 sha1_array_append(sa
, ref
->old_sha1
);
866 static void add_alternate_refs(void)
868 struct sha1_array sa
= SHA1_ARRAY_INIT
;
869 for_each_alternate_ref(collect_one_alternate_ref
, &sa
);
870 sha1_array_for_each_unique(&sa
, add_one_alternate_sha1
, NULL
);
871 sha1_array_clear(&sa
);
874 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
876 int advertise_refs
= 0;
877 int stateless_rpc
= 0;
880 struct command
*commands
;
882 packet_trace_identity("receive-pack");
885 for (i
= 1; i
< argc
; i
++) {
886 const char *arg
= *argv
++;
889 if (!strcmp(arg
, "--advertise-refs")) {
893 if (!strcmp(arg
, "--stateless-rpc")) {
898 usage(receive_pack_usage
);
901 usage(receive_pack_usage
);
905 usage(receive_pack_usage
);
909 if (!enter_repo(dir
, 0))
910 die("'%s' does not appear to be a git repository", dir
);
912 if (is_repository_shallow())
913 die("attempt to push into a shallow repository");
915 git_config(receive_pack_config
, NULL
);
917 if (0 <= transfer_unpack_limit
)
918 unpack_limit
= transfer_unpack_limit
;
919 else if (0 <= receive_unpack_limit
)
920 unpack_limit
= receive_unpack_limit
;
922 if (advertise_refs
|| !stateless_rpc
) {
923 add_alternate_refs();
933 if ((commands
= read_head_info()) != NULL
) {
934 const char *unpack_status
= NULL
;
936 if (!delete_only(commands
))
937 unpack_status
= unpack();
938 execute_commands(commands
, unpack_status
);
940 unlink_or_warn(pack_lockfile
);
942 report(commands
, unpack_status
);
943 run_receive_hook(commands
, post_receive_hook
);
944 run_update_post_hook(commands
);
946 const char *argv_gc_auto
[] = {
947 "gc", "--auto", "--quiet", NULL
,
949 run_command_v_opt(argv_gc_auto
, RUN_GIT_CMD
);
951 if (auto_update_server_info
)
952 update_server_info(0);