6 #include "run-command.h"
12 #include "transport.h"
13 #include "string-list.h"
14 #include "sha1-array.h"
15 #include "connected.h"
18 static const char receive_pack_usage
[] = "git receive-pack <git-dir>";
27 static int deny_deletes
;
28 static int deny_non_fast_forwards
;
29 static enum deny_action deny_current_branch
= DENY_UNCONFIGURED
;
30 static enum deny_action deny_delete_current
= DENY_UNCONFIGURED
;
31 static int receive_fsck_objects
= -1;
32 static int transfer_fsck_objects
= -1;
33 static int receive_unpack_limit
= -1;
34 static int transfer_unpack_limit
= -1;
35 static int unpack_limit
= 100;
36 static int report_status
;
37 static int use_sideband
;
39 static int prefer_ofs_delta
= 1;
40 static int auto_update_server_info
;
41 static int auto_gc
= 1;
42 static int fix_thin
= 1;
43 static const char *head_name
;
44 static void *head_name_to_free
;
45 static int sent_capabilities
;
47 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
50 if (!strcasecmp(value
, "ignore"))
52 if (!strcasecmp(value
, "warn"))
54 if (!strcasecmp(value
, "refuse"))
57 if (git_config_bool(var
, value
))
62 static int receive_pack_config(const char *var
, const char *value
, void *cb
)
64 int status
= parse_hide_refs_config(var
, value
, "receive");
69 if (strcmp(var
, "receive.denydeletes") == 0) {
70 deny_deletes
= git_config_bool(var
, value
);
74 if (strcmp(var
, "receive.denynonfastforwards") == 0) {
75 deny_non_fast_forwards
= git_config_bool(var
, value
);
79 if (strcmp(var
, "receive.unpacklimit") == 0) {
80 receive_unpack_limit
= git_config_int(var
, value
);
84 if (strcmp(var
, "transfer.unpacklimit") == 0) {
85 transfer_unpack_limit
= git_config_int(var
, value
);
89 if (strcmp(var
, "receive.fsckobjects") == 0) {
90 receive_fsck_objects
= git_config_bool(var
, value
);
94 if (strcmp(var
, "transfer.fsckobjects") == 0) {
95 transfer_fsck_objects
= git_config_bool(var
, value
);
99 if (!strcmp(var
, "receive.denycurrentbranch")) {
100 deny_current_branch
= parse_deny_action(var
, value
);
104 if (strcmp(var
, "receive.denydeletecurrent") == 0) {
105 deny_delete_current
= parse_deny_action(var
, value
);
109 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
110 prefer_ofs_delta
= git_config_bool(var
, value
);
114 if (strcmp(var
, "receive.updateserverinfo") == 0) {
115 auto_update_server_info
= git_config_bool(var
, value
);
119 if (strcmp(var
, "receive.autogc") == 0) {
120 auto_gc
= git_config_bool(var
, value
);
124 return git_default_config(var
, value
, cb
);
127 static void show_ref(const char *path
, const unsigned char *sha1
)
129 if (ref_is_hidden(path
))
132 if (sent_capabilities
)
133 packet_write(1, "%s %s\n", sha1_to_hex(sha1
), path
);
135 packet_write(1, "%s %s%c%s%s agent=%s\n",
136 sha1_to_hex(sha1
), path
, 0,
137 " report-status delete-refs side-band-64k quiet",
138 prefer_ofs_delta
? " ofs-delta" : "",
139 git_user_agent_sanitized());
140 sent_capabilities
= 1;
143 static int show_ref_cb(const char *path
, const unsigned char *sha1
, int flag
, void *unused
)
145 path
= strip_namespace(path
);
147 * Advertise refs outside our current namespace as ".have"
148 * refs, so that the client can use them to minimize data
149 * transfer but will otherwise ignore them. This happens to
150 * cover ".have" that are thrown in by add_one_alternate_ref()
151 * to mark histories that are complete in our alternates as
156 show_ref(path
, sha1
);
160 static void show_one_alternate_sha1(const unsigned char sha1
[20], void *unused
)
162 show_ref(".have", sha1
);
165 static void collect_one_alternate_ref(const struct ref
*ref
, void *data
)
167 struct sha1_array
*sa
= data
;
168 sha1_array_append(sa
, ref
->old_sha1
);
171 static void write_head_info(void)
173 struct sha1_array sa
= SHA1_ARRAY_INIT
;
174 for_each_alternate_ref(collect_one_alternate_ref
, &sa
);
175 sha1_array_for_each_unique(&sa
, show_one_alternate_sha1
, NULL
);
176 sha1_array_clear(&sa
);
177 for_each_ref(show_ref_cb
, NULL
);
178 if (!sent_capabilities
)
179 show_ref("capabilities^{}", null_sha1
);
181 advertise_shallow_grafts(1);
188 struct command
*next
;
189 const char *error_string
;
190 unsigned int skip_update
:1,
192 unsigned char old_sha1
[20];
193 unsigned char new_sha1
[20];
194 char ref_name
[FLEX_ARRAY
]; /* more */
197 static void rp_error(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
198 static void rp_warning(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
200 static void report_message(const char *prefix
, const char *err
, va_list params
)
202 int sz
= strlen(prefix
);
205 strncpy(msg
, prefix
, sz
);
206 sz
+= vsnprintf(msg
+ sz
, sizeof(msg
) - sz
, err
, params
);
207 if (sz
> (sizeof(msg
) - 1))
208 sz
= sizeof(msg
) - 1;
212 send_sideband(1, 2, msg
, sz
, use_sideband
);
217 static void rp_warning(const char *err
, ...)
220 va_start(params
, err
);
221 report_message("warning: ", err
, params
);
225 static void rp_error(const char *err
, ...)
228 va_start(params
, err
);
229 report_message("error: ", err
, params
);
233 static int copy_to_sideband(int in
, int out
, void *arg
)
237 ssize_t sz
= xread(in
, data
, sizeof(data
));
240 send_sideband(1, 2, data
, sz
, use_sideband
);
246 typedef int (*feed_fn
)(void *, const char **, size_t *);
247 static int run_and_feed_hook(const char *hook_name
, feed_fn feed
, void *feed_state
)
249 struct child_process proc
;
254 argv
[0] = find_hook(hook_name
);
260 memset(&proc
, 0, sizeof(proc
));
263 proc
.stdout_to_stderr
= 1;
266 memset(&muxer
, 0, sizeof(muxer
));
267 muxer
.proc
= copy_to_sideband
;
269 code
= start_async(&muxer
);
275 code
= start_command(&proc
);
278 finish_async(&muxer
);
285 if (feed(feed_state
, &buf
, &n
))
287 if (write_in_full(proc
.in
, buf
, n
) != n
)
292 finish_async(&muxer
);
293 return finish_command(&proc
);
296 struct receive_hook_feed_state
{
302 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
304 struct receive_hook_feed_state
*state
= state_
;
305 struct command
*cmd
= state
->cmd
;
308 state
->skip_broken
&& (cmd
->error_string
|| cmd
->did_not_exist
))
312 strbuf_reset(&state
->buf
);
313 strbuf_addf(&state
->buf
, "%s %s %s\n",
314 sha1_to_hex(cmd
->old_sha1
), sha1_to_hex(cmd
->new_sha1
),
316 state
->cmd
= cmd
->next
;
318 *bufp
= state
->buf
.buf
;
319 *sizep
= state
->buf
.len
;
324 static int run_receive_hook(struct command
*commands
, const char *hook_name
,
327 struct receive_hook_feed_state state
;
330 strbuf_init(&state
.buf
, 0);
331 state
.cmd
= commands
;
332 state
.skip_broken
= skip_broken
;
333 if (feed_receive_hook(&state
, NULL
, NULL
))
335 state
.cmd
= commands
;
336 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
337 strbuf_release(&state
.buf
);
341 static int run_update_hook(struct command
*cmd
)
344 struct child_process proc
;
347 argv
[0] = find_hook("update");
351 argv
[1] = cmd
->ref_name
;
352 argv
[2] = sha1_to_hex(cmd
->old_sha1
);
353 argv
[3] = sha1_to_hex(cmd
->new_sha1
);
356 memset(&proc
, 0, sizeof(proc
));
358 proc
.stdout_to_stderr
= 1;
359 proc
.err
= use_sideband
? -1 : 0;
362 code
= start_command(&proc
);
366 copy_to_sideband(proc
.err
, -1, NULL
);
367 return finish_command(&proc
);
370 static int is_ref_checked_out(const char *ref
)
372 if (is_bare_repository())
377 return !strcmp(head_name
, ref
);
380 static char *refuse_unconfigured_deny_msg
[] = {
381 "By default, updating the current branch in a non-bare repository",
382 "is denied, because it will make the index and work tree inconsistent",
383 "with what you pushed, and will require 'git reset --hard' to match",
384 "the work tree to HEAD.",
386 "You can set 'receive.denyCurrentBranch' configuration variable to",
387 "'ignore' or 'warn' in the remote repository to allow pushing into",
388 "its current branch; however, this is not recommended unless you",
389 "arranged to update its work tree to match what you pushed in some",
392 "To squelch this message and still keep the default behaviour, set",
393 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
396 static void refuse_unconfigured_deny(void)
399 for (i
= 0; i
< ARRAY_SIZE(refuse_unconfigured_deny_msg
); i
++)
400 rp_error("%s", refuse_unconfigured_deny_msg
[i
]);
403 static char *refuse_unconfigured_deny_delete_current_msg
[] = {
404 "By default, deleting the current branch is denied, because the next",
405 "'git clone' won't result in any file checked out, causing confusion.",
407 "You can set 'receive.denyDeleteCurrent' configuration variable to",
408 "'warn' or 'ignore' in the remote repository to allow deleting the",
409 "current branch, with or without a warning message.",
411 "To squelch this message, you can set it to 'refuse'."
414 static void refuse_unconfigured_deny_delete_current(void)
418 i
< ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg
);
420 rp_error("%s", refuse_unconfigured_deny_delete_current_msg
[i
]);
423 static const char *update(struct command
*cmd
)
425 const char *name
= cmd
->ref_name
;
426 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
427 const char *namespaced_name
;
428 unsigned char *old_sha1
= cmd
->old_sha1
;
429 unsigned char *new_sha1
= cmd
->new_sha1
;
430 struct ref_lock
*lock
;
432 /* only refs/... are allowed */
433 if (prefixcmp(name
, "refs/") || check_refname_format(name
+ 5, 0)) {
434 rp_error("refusing to create funny ref '%s' remotely", name
);
435 return "funny refname";
438 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
439 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
441 if (is_ref_checked_out(namespaced_name
)) {
442 switch (deny_current_branch
) {
446 rp_warning("updating the current branch");
449 case DENY_UNCONFIGURED
:
450 rp_error("refusing to update checked out branch: %s", name
);
451 if (deny_current_branch
== DENY_UNCONFIGURED
)
452 refuse_unconfigured_deny();
453 return "branch is currently checked out";
457 if (!is_null_sha1(new_sha1
) && !has_sha1_file(new_sha1
)) {
458 error("unpack should have generated %s, "
459 "but I can't find it!", sha1_to_hex(new_sha1
));
463 if (!is_null_sha1(old_sha1
) && is_null_sha1(new_sha1
)) {
464 if (deny_deletes
&& !prefixcmp(name
, "refs/heads/")) {
465 rp_error("denying ref deletion for %s", name
);
466 return "deletion prohibited";
469 if (!strcmp(namespaced_name
, head_name
)) {
470 switch (deny_delete_current
) {
474 rp_warning("deleting the current branch");
477 case DENY_UNCONFIGURED
:
478 if (deny_delete_current
== DENY_UNCONFIGURED
)
479 refuse_unconfigured_deny_delete_current();
480 rp_error("refusing to delete the current branch: %s", name
);
481 return "deletion of the current branch prohibited";
486 if (deny_non_fast_forwards
&& !is_null_sha1(new_sha1
) &&
487 !is_null_sha1(old_sha1
) &&
488 !prefixcmp(name
, "refs/heads/")) {
489 struct object
*old_object
, *new_object
;
490 struct commit
*old_commit
, *new_commit
;
492 old_object
= parse_object(old_sha1
);
493 new_object
= parse_object(new_sha1
);
495 if (!old_object
|| !new_object
||
496 old_object
->type
!= OBJ_COMMIT
||
497 new_object
->type
!= OBJ_COMMIT
) {
498 error("bad sha1 objects for %s", name
);
501 old_commit
= (struct commit
*)old_object
;
502 new_commit
= (struct commit
*)new_object
;
503 if (!in_merge_bases(old_commit
, new_commit
)) {
504 rp_error("denying non-fast-forward %s"
505 " (you should pull first)", name
);
506 return "non-fast-forward";
509 if (run_update_hook(cmd
)) {
510 rp_error("hook declined to update %s", name
);
511 return "hook declined";
514 if (is_null_sha1(new_sha1
)) {
515 if (!parse_object(old_sha1
)) {
517 if (ref_exists(name
)) {
518 rp_warning("Allowing deletion of corrupt ref.");
520 rp_warning("Deleting a non-existent ref.");
521 cmd
->did_not_exist
= 1;
524 if (delete_ref(namespaced_name
, old_sha1
, 0)) {
525 rp_error("failed to delete %s", name
);
526 return "failed to delete";
528 return NULL
; /* good */
531 lock
= lock_any_ref_for_update(namespaced_name
, old_sha1
,
534 rp_error("failed to lock %s", name
);
535 return "failed to lock";
537 if (write_ref_sha1(lock
, new_sha1
, "push")) {
538 return "failed to write"; /* error() already called */
540 return NULL
; /* good */
544 static void run_update_post_hook(struct command
*commands
)
549 struct child_process proc
;
552 hook
= find_hook("post-update");
553 for (argc
= 0, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
554 if (cmd
->error_string
|| cmd
->did_not_exist
)
561 argv
= xmalloc(sizeof(*argv
) * (2 + argc
));
564 for (argc
= 1, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
566 if (cmd
->error_string
|| cmd
->did_not_exist
)
568 p
= xmalloc(strlen(cmd
->ref_name
) + 1);
569 strcpy(p
, cmd
->ref_name
);
575 memset(&proc
, 0, sizeof(proc
));
577 proc
.stdout_to_stderr
= 1;
578 proc
.err
= use_sideband
? -1 : 0;
581 if (!start_command(&proc
)) {
583 copy_to_sideband(proc
.err
, -1, NULL
);
584 finish_command(&proc
);
588 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
590 struct strbuf buf
= STRBUF_INIT
;
591 const char *dst_name
;
592 struct string_list_item
*item
;
593 struct command
*dst_cmd
;
594 unsigned char sha1
[20];
595 char cmd_oldh
[41], cmd_newh
[41], dst_oldh
[41], dst_newh
[41];
598 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
599 dst_name
= resolve_ref_unsafe(buf
.buf
, sha1
, 0, &flag
);
600 strbuf_release(&buf
);
602 if (!(flag
& REF_ISSYMREF
))
605 dst_name
= strip_namespace(dst_name
);
607 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
608 cmd
->skip_update
= 1;
609 cmd
->error_string
= "broken symref";
613 if ((item
= string_list_lookup(list
, dst_name
)) == NULL
)
616 cmd
->skip_update
= 1;
618 dst_cmd
= (struct command
*) item
->util
;
620 if (!hashcmp(cmd
->old_sha1
, dst_cmd
->old_sha1
) &&
621 !hashcmp(cmd
->new_sha1
, dst_cmd
->new_sha1
))
624 dst_cmd
->skip_update
= 1;
626 strcpy(cmd_oldh
, find_unique_abbrev(cmd
->old_sha1
, DEFAULT_ABBREV
));
627 strcpy(cmd_newh
, find_unique_abbrev(cmd
->new_sha1
, DEFAULT_ABBREV
));
628 strcpy(dst_oldh
, find_unique_abbrev(dst_cmd
->old_sha1
, DEFAULT_ABBREV
));
629 strcpy(dst_newh
, find_unique_abbrev(dst_cmd
->new_sha1
, DEFAULT_ABBREV
));
630 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
631 " its target '%s' (%s..%s)",
632 cmd
->ref_name
, cmd_oldh
, cmd_newh
,
633 dst_cmd
->ref_name
, dst_oldh
, dst_newh
);
635 cmd
->error_string
= dst_cmd
->error_string
=
636 "inconsistent aliased update";
639 static void check_aliased_updates(struct command
*commands
)
642 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
644 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
645 struct string_list_item
*item
=
646 string_list_append(&ref_list
, cmd
->ref_name
);
647 item
->util
= (void *)cmd
;
649 sort_string_list(&ref_list
);
651 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
652 if (!cmd
->error_string
)
653 check_aliased_update(cmd
, &ref_list
);
656 string_list_clear(&ref_list
, 0);
659 static int command_singleton_iterator(void *cb_data
, unsigned char sha1
[20])
661 struct command
**cmd_list
= cb_data
;
662 struct command
*cmd
= *cmd_list
;
664 if (!cmd
|| is_null_sha1(cmd
->new_sha1
))
665 return -1; /* end of list */
666 *cmd_list
= NULL
; /* this returns only one */
667 hashcpy(sha1
, cmd
->new_sha1
);
671 static void set_connectivity_errors(struct command
*commands
)
675 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
676 struct command
*singleton
= cmd
;
677 if (!check_everything_connected(command_singleton_iterator
,
680 cmd
->error_string
= "missing necessary objects";
684 static int iterate_receive_command_list(void *cb_data
, unsigned char sha1
[20])
686 struct command
**cmd_list
= cb_data
;
687 struct command
*cmd
= *cmd_list
;
690 if (!is_null_sha1(cmd
->new_sha1
)) {
691 hashcpy(sha1
, cmd
->new_sha1
);
692 *cmd_list
= cmd
->next
;
698 return -1; /* end of list */
701 static void reject_updates_to_hidden(struct command
*commands
)
705 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
706 if (cmd
->error_string
|| !ref_is_hidden(cmd
->ref_name
))
708 if (is_null_sha1(cmd
->new_sha1
))
709 cmd
->error_string
= "deny deleting a hidden ref";
711 cmd
->error_string
= "deny updating a hidden ref";
715 static void execute_commands(struct command
*commands
, const char *unpacker_error
)
718 unsigned char sha1
[20];
720 if (unpacker_error
) {
721 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
722 cmd
->error_string
= "unpacker error";
727 if (check_everything_connected(iterate_receive_command_list
,
729 set_connectivity_errors(commands
);
731 reject_updates_to_hidden(commands
);
733 if (run_receive_hook(commands
, "pre-receive", 0)) {
734 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
735 if (!cmd
->error_string
)
736 cmd
->error_string
= "pre-receive hook declined";
741 check_aliased_updates(commands
);
743 free(head_name_to_free
);
744 head_name
= head_name_to_free
= resolve_refdup("HEAD", sha1
, 0, NULL
);
746 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
747 if (cmd
->error_string
)
750 if (cmd
->skip_update
)
753 cmd
->error_string
= update(cmd
);
757 static struct command
*read_head_info(void)
759 struct command
*commands
= NULL
;
760 struct command
**p
= &commands
;
763 unsigned char old_sha1
[20], new_sha1
[20];
768 line
= packet_read_line(0, &len
);
774 get_sha1_hex(line
, old_sha1
) ||
775 get_sha1_hex(line
+ 41, new_sha1
))
776 die("protocol error: expected old/new/ref, got '%s'",
780 reflen
= strlen(refname
);
781 if (reflen
+ 82 < len
) {
782 const char *feature_list
= refname
+ reflen
+ 1;
783 if (parse_feature_request(feature_list
, "report-status"))
785 if (parse_feature_request(feature_list
, "side-band-64k"))
786 use_sideband
= LARGE_PACKET_MAX
;
787 if (parse_feature_request(feature_list
, "quiet"))
790 cmd
= xcalloc(1, sizeof(struct command
) + len
- 80);
791 hashcpy(cmd
->old_sha1
, old_sha1
);
792 hashcpy(cmd
->new_sha1
, new_sha1
);
793 memcpy(cmd
->ref_name
, line
+ 82, len
- 81);
800 static const char *parse_pack_header(struct pack_header
*hdr
)
802 switch (read_pack_header(0, hdr
)) {
804 return "eof before pack header was fully read";
806 case PH_ERROR_PACK_SIGNATURE
:
807 return "protocol error (pack signature mismatch detected)";
809 case PH_ERROR_PROTOCOL
:
810 return "protocol error (pack version unsupported)";
813 return "unknown error in parse_pack_header";
820 static const char *pack_lockfile
;
822 static const char *unpack(int err_fd
)
824 struct pack_header hdr
;
827 int fsck_objects
= (receive_fsck_objects
>= 0
828 ? receive_fsck_objects
829 : transfer_fsck_objects
>= 0
830 ? transfer_fsck_objects
833 hdr_err
= parse_pack_header(&hdr
);
839 snprintf(hdr_arg
, sizeof(hdr_arg
),
840 "--pack_header=%"PRIu32
",%"PRIu32
,
841 ntohl(hdr
.hdr_version
), ntohl(hdr
.hdr_entries
));
843 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
845 struct child_process child
;
846 const char *unpacker
[5];
847 unpacker
[i
++] = "unpack-objects";
849 unpacker
[i
++] = "-q";
851 unpacker
[i
++] = "--strict";
852 unpacker
[i
++] = hdr_arg
;
853 unpacker
[i
++] = NULL
;
854 memset(&child
, 0, sizeof(child
));
855 child
.argv
= unpacker
;
859 code
= run_command(&child
);
862 return "unpack-objects abnormal exit";
864 const char *keeper
[7];
865 int s
, status
, i
= 0;
867 struct child_process ip
;
869 s
= sprintf(keep_arg
, "--keep=receive-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
870 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
871 strcpy(keep_arg
+ s
, "localhost");
873 keeper
[i
++] = "index-pack";
874 keeper
[i
++] = "--stdin";
876 keeper
[i
++] = "--strict";
878 keeper
[i
++] = "--fix-thin";
879 keeper
[i
++] = hdr_arg
;
880 keeper
[i
++] = keep_arg
;
882 memset(&ip
, 0, sizeof(ip
));
887 status
= start_command(&ip
);
889 return "index-pack fork failed";
891 pack_lockfile
= index_pack_lockfile(ip
.out
);
893 status
= finish_command(&ip
);
895 reprepare_packed_git();
898 return "index-pack abnormal exit";
902 static const char *unpack_with_sideband(void)
910 memset(&muxer
, 0, sizeof(muxer
));
911 muxer
.proc
= copy_to_sideband
;
913 if (start_async(&muxer
))
916 ret
= unpack(muxer
.in
);
918 finish_async(&muxer
);
922 static void report(struct command
*commands
, const char *unpack_status
)
925 struct strbuf buf
= STRBUF_INIT
;
927 packet_buf_write(&buf
, "unpack %s\n",
928 unpack_status
? unpack_status
: "ok");
929 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
930 if (!cmd
->error_string
)
931 packet_buf_write(&buf
, "ok %s\n",
934 packet_buf_write(&buf
, "ng %s %s\n",
935 cmd
->ref_name
, cmd
->error_string
);
937 packet_buf_flush(&buf
);
940 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
942 write_or_die(1, buf
.buf
, buf
.len
);
943 strbuf_release(&buf
);
946 static int delete_only(struct command
*commands
)
949 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
950 if (!is_null_sha1(cmd
->new_sha1
))
956 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
958 int advertise_refs
= 0;
959 int stateless_rpc
= 0;
962 struct command
*commands
;
964 packet_trace_identity("receive-pack");
967 for (i
= 1; i
< argc
; i
++) {
968 const char *arg
= *argv
++;
971 if (!strcmp(arg
, "--quiet")) {
976 if (!strcmp(arg
, "--advertise-refs")) {
980 if (!strcmp(arg
, "--stateless-rpc")) {
984 if (!strcmp(arg
, "--reject-thin-pack-for-testing")) {
989 usage(receive_pack_usage
);
992 usage(receive_pack_usage
);
996 usage(receive_pack_usage
);
1000 if (!enter_repo(dir
, 0))
1001 die("'%s' does not appear to be a git repository", dir
);
1003 if (is_repository_shallow() && stateless_rpc
)
1004 die("attempt to push into a shallow repository");
1006 git_config(receive_pack_config
, NULL
);
1008 if (0 <= transfer_unpack_limit
)
1009 unpack_limit
= transfer_unpack_limit
;
1010 else if (0 <= receive_unpack_limit
)
1011 unpack_limit
= receive_unpack_limit
;
1013 if (advertise_refs
|| !stateless_rpc
) {
1019 if ((commands
= read_head_info()) != NULL
) {
1020 const char *unpack_status
= NULL
;
1022 if (!delete_only(commands
))
1023 unpack_status
= unpack_with_sideband();
1024 execute_commands(commands
, unpack_status
);
1026 unlink_or_warn(pack_lockfile
);
1028 report(commands
, unpack_status
);
1029 run_receive_hook(commands
, "post-receive", 1);
1030 run_update_post_hook(commands
);
1032 const char *argv_gc_auto
[] = {
1033 "gc", "--auto", "--quiet", NULL
,
1035 int opt
= RUN_GIT_CMD
| RUN_COMMAND_STDOUT_TO_STDERR
;
1036 run_command_v_opt(argv_gc_auto
, opt
);
1038 if (auto_update_server_info
)
1039 update_server_info(0);