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>";
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
;
38 static int prefer_ofs_delta
= 1;
39 static int auto_update_server_info
;
40 static int auto_gc
= 1;
41 static const char *head_name
;
42 static int sent_capabilities
;
44 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
47 if (!strcasecmp(value
, "ignore"))
49 if (!strcasecmp(value
, "warn"))
51 if (!strcasecmp(value
, "refuse"))
54 if (git_config_bool(var
, value
))
59 static int receive_pack_config(const char *var
, const char *value
, void *cb
)
61 if (strcmp(var
, "receive.denydeletes") == 0) {
62 deny_deletes
= git_config_bool(var
, value
);
66 if (strcmp(var
, "receive.denynonfastforwards") == 0) {
67 deny_non_fast_forwards
= git_config_bool(var
, value
);
71 if (strcmp(var
, "receive.unpacklimit") == 0) {
72 receive_unpack_limit
= git_config_int(var
, value
);
76 if (strcmp(var
, "transfer.unpacklimit") == 0) {
77 transfer_unpack_limit
= git_config_int(var
, value
);
81 if (strcmp(var
, "receive.fsckobjects") == 0) {
82 receive_fsck_objects
= git_config_bool(var
, value
);
86 if (strcmp(var
, "transfer.fsckobjects") == 0) {
87 transfer_fsck_objects
= git_config_bool(var
, value
);
91 if (!strcmp(var
, "receive.denycurrentbranch")) {
92 if (value
&& !strcasecmp(value
, "updateinstead"))
93 deny_current_branch
= DENY_UPDATE_INSTEAD
;
94 else if (value
&& !strcasecmp(value
, "detachinstead"))
95 deny_current_branch
= DENY_DETACH_INSTEAD
;
97 deny_current_branch
= parse_deny_action(var
, value
);
101 if (strcmp(var
, "receive.denydeletecurrent") == 0) {
102 deny_delete_current
= parse_deny_action(var
, value
);
106 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
107 prefer_ofs_delta
= git_config_bool(var
, value
);
111 if (strcmp(var
, "receive.updateserverinfo") == 0) {
112 auto_update_server_info
= git_config_bool(var
, value
);
116 if (strcmp(var
, "receive.autogc") == 0) {
117 auto_gc
= git_config_bool(var
, value
);
121 return git_default_config(var
, value
, cb
);
124 static int show_ref(const char *path
, const unsigned char *sha1
, int flag
, void *cb_data
)
126 if (sent_capabilities
)
127 packet_write(1, "%s %s\n", sha1_to_hex(sha1
), path
);
129 packet_write(1, "%s %s%c%s%s\n",
130 sha1_to_hex(sha1
), path
, 0,
131 " report-status delete-refs side-band-64k",
132 prefer_ofs_delta
? " ofs-delta" : "");
133 sent_capabilities
= 1;
137 static int show_ref_cb(const char *path
, const unsigned char *sha1
, int flag
, void *cb_data
)
139 path
= strip_namespace(path
);
141 * Advertise refs outside our current namespace as ".have"
142 * refs, so that the client can use them to minimize data
143 * transfer but will otherwise ignore them. This happens to
144 * cover ".have" that are thrown in by add_one_alternate_ref()
145 * to mark histories that are complete in our alternates as
150 return show_ref(path
, sha1
, flag
, cb_data
);
153 static void write_head_info(void)
155 for_each_ref(show_ref_cb
, NULL
);
156 if (!sent_capabilities
)
157 show_ref("capabilities^{}", null_sha1
, 0, NULL
);
162 struct command
*next
;
163 const char *error_string
;
164 unsigned int skip_update
:1,
166 unsigned char old_sha1
[20];
167 unsigned char new_sha1
[20];
168 char ref_name
[FLEX_ARRAY
]; /* more */
171 static const char pre_receive_hook
[] = "hooks/pre-receive";
172 static const char post_receive_hook
[] = "hooks/post-receive";
174 static void rp_error(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
175 static void rp_warning(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
177 static void report_message(const char *prefix
, const char *err
, va_list params
)
179 int sz
= strlen(prefix
);
182 strncpy(msg
, prefix
, sz
);
183 sz
+= vsnprintf(msg
+ sz
, sizeof(msg
) - sz
, err
, params
);
184 if (sz
> (sizeof(msg
) - 1))
185 sz
= sizeof(msg
) - 1;
189 send_sideband(1, 2, msg
, sz
, use_sideband
);
194 static void rp_warning(const char *err
, ...)
197 va_start(params
, err
);
198 report_message("warning: ", err
, params
);
202 static void rp_error(const char *err
, ...)
205 va_start(params
, err
);
206 report_message("error: ", err
, params
);
210 static int copy_to_sideband(int in
, int out
, void *arg
)
214 ssize_t sz
= xread(in
, data
, sizeof(data
));
217 send_sideband(1, 2, data
, sz
, use_sideband
);
223 typedef int (*feed_fn
)(void *, const char **, size_t *);
224 static int run_and_feed_hook(const char *hook_name
, feed_fn feed
, void *feed_state
)
226 struct child_process proc
;
231 if (access(hook_name
, X_OK
) < 0)
237 memset(&proc
, 0, sizeof(proc
));
240 proc
.stdout_to_stderr
= 1;
243 memset(&muxer
, 0, sizeof(muxer
));
244 muxer
.proc
= copy_to_sideband
;
246 code
= start_async(&muxer
);
252 code
= start_command(&proc
);
255 finish_async(&muxer
);
262 if (feed(feed_state
, &buf
, &n
))
264 if (write_in_full(proc
.in
, buf
, n
) != n
)
269 finish_async(&muxer
);
270 return finish_command(&proc
);
273 struct receive_hook_feed_state
{
279 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
281 struct receive_hook_feed_state
*state
= state_
;
282 struct command
*cmd
= state
->cmd
;
285 state
->skip_broken
&& (cmd
->error_string
|| cmd
->did_not_exist
))
289 strbuf_reset(&state
->buf
);
290 strbuf_addf(&state
->buf
, "%s %s %s\n",
291 sha1_to_hex(cmd
->old_sha1
), sha1_to_hex(cmd
->new_sha1
),
293 state
->cmd
= cmd
->next
;
295 *bufp
= state
->buf
.buf
;
296 *sizep
= state
->buf
.len
;
301 static int run_receive_hook(struct command
*commands
, const char *hook_name
,
304 struct receive_hook_feed_state state
;
307 strbuf_init(&state
.buf
, 0);
308 state
.cmd
= commands
;
309 state
.skip_broken
= skip_broken
;
310 if (feed_receive_hook(&state
, NULL
, NULL
))
312 state
.cmd
= commands
;
313 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
314 strbuf_release(&state
.buf
);
318 static int run_update_hook(struct command
*cmd
)
320 static const char update_hook
[] = "hooks/update";
322 struct child_process proc
;
325 if (access(update_hook
, X_OK
) < 0)
328 argv
[0] = update_hook
;
329 argv
[1] = cmd
->ref_name
;
330 argv
[2] = sha1_to_hex(cmd
->old_sha1
);
331 argv
[3] = sha1_to_hex(cmd
->new_sha1
);
334 memset(&proc
, 0, sizeof(proc
));
336 proc
.stdout_to_stderr
= 1;
337 proc
.err
= use_sideband
? -1 : 0;
340 code
= start_command(&proc
);
344 copy_to_sideband(proc
.err
, -1, NULL
);
345 return finish_command(&proc
);
348 static int is_ref_checked_out(const char *ref
)
350 if (is_bare_repository())
355 return !strcmp(head_name
, ref
);
358 static char *refuse_unconfigured_deny_msg
[] = {
359 "By default, updating the current branch in a non-bare repository",
360 "is denied, because it will make the index and work tree inconsistent",
361 "with what you pushed, and will require 'git reset --hard' to match",
362 "the work tree to HEAD.",
364 "You can set 'receive.denyCurrentBranch' configuration variable to",
365 "'ignore' or 'warn' in the remote repository to allow pushing into",
366 "its current branch; however, this is not recommended unless you",
367 "arranged to update its work tree to match what you pushed in some",
370 "To squelch this message and still keep the default behaviour, set",
371 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
374 static void refuse_unconfigured_deny(void)
377 for (i
= 0; i
< ARRAY_SIZE(refuse_unconfigured_deny_msg
); i
++)
378 rp_error("%s", refuse_unconfigured_deny_msg
[i
]);
381 static char *refuse_unconfigured_deny_delete_current_msg
[] = {
382 "By default, deleting the current branch is denied, because the next",
383 "'git clone' won't result in any file checked out, causing confusion.",
385 "You can set 'receive.denyDeleteCurrent' configuration variable to",
386 "'warn' or 'ignore' in the remote repository to allow deleting the",
387 "current branch, with or without a warning message.",
389 "To squelch this message, you can set it to 'refuse'."
392 static void refuse_unconfigured_deny_delete_current(void)
396 i
< ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg
);
398 rp_error("%s", refuse_unconfigured_deny_delete_current_msg
[i
]);
401 static void merge_worktree(unsigned char *sha1
)
403 const char *update_refresh
[] = {
404 "update-index", "--ignore-submodules", "--refresh", NULL
406 const char *read_tree
[] = {
407 "read-tree", "-u", "-m", sha1_to_hex(sha1
), NULL
409 struct child_process child
;
410 struct strbuf git_env
= STRBUF_INIT
;
413 if (is_bare_repository())
414 die ("denyCurrentBranch = updateInstead needs a worktree");
416 strbuf_addf(&git_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
417 env
[0] = git_env
.buf
;
420 memset(&child
, 0, sizeof(child
));
421 child
.argv
= update_refresh
;
423 child
.dir
= git_work_tree_cfg
? git_work_tree_cfg
: "..";
424 child
.stdout_to_stderr
= 1;
426 if (run_command(&child
))
427 die ("Could not refresh the index");
429 child
.argv
= read_tree
;
432 child
.stdout_to_stderr
= 0;
433 if (run_command(&child
))
434 die ("Could not merge working tree with new HEAD. Good luck.");
436 strbuf_release(&git_env
);
439 static const char *update(struct command
*cmd
)
441 const char *name
= cmd
->ref_name
;
442 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
443 const char *namespaced_name
;
444 unsigned char *old_sha1
= cmd
->old_sha1
;
445 unsigned char *new_sha1
= cmd
->new_sha1
;
446 struct ref_lock
*lock
;
448 /* only refs/... are allowed */
449 if (prefixcmp(name
, "refs/") || check_refname_format(name
+ 5, 0)) {
450 rp_error("refusing to create funny ref '%s' remotely", name
);
451 return "funny refname";
454 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
455 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
457 if (is_ref_checked_out(namespaced_name
)) {
458 switch (deny_current_branch
) {
462 rp_warning("updating the current branch");
465 case DENY_UNCONFIGURED
:
466 rp_error("refusing to update checked out branch: %s", name
);
467 if (deny_current_branch
== DENY_UNCONFIGURED
)
468 refuse_unconfigured_deny();
469 return "branch is currently checked out";
470 case DENY_UPDATE_INSTEAD
:
471 merge_worktree(new_sha1
);
473 case DENY_DETACH_INSTEAD
:
474 update_ref("push into current branch (detach)", "HEAD",
475 old_sha1
, NULL
, REF_NODEREF
, DIE_ON_ERR
);
480 if (!is_null_sha1(new_sha1
) && !has_sha1_file(new_sha1
)) {
481 error("unpack should have generated %s, "
482 "but I can't find it!", sha1_to_hex(new_sha1
));
486 if (!is_null_sha1(old_sha1
) && is_null_sha1(new_sha1
)) {
487 if (deny_deletes
&& !prefixcmp(name
, "refs/heads/")) {
488 rp_error("denying ref deletion for %s", name
);
489 return "deletion prohibited";
492 if (!strcmp(namespaced_name
, head_name
)) {
493 switch (deny_delete_current
) {
497 rp_warning("deleting the current branch");
500 case DENY_UNCONFIGURED
:
501 if (deny_delete_current
== DENY_UNCONFIGURED
)
502 refuse_unconfigured_deny_delete_current();
503 rp_error("refusing to delete the current branch: %s", name
);
504 return "deletion of the current branch prohibited";
506 die ("Invalid denyDeleteCurrent setting");
511 if (deny_non_fast_forwards
&& !is_null_sha1(new_sha1
) &&
512 !is_null_sha1(old_sha1
) &&
513 !prefixcmp(name
, "refs/heads/")) {
514 struct object
*old_object
, *new_object
;
515 struct commit
*old_commit
, *new_commit
;
516 struct commit_list
*bases
, *ent
;
518 old_object
= parse_object(old_sha1
);
519 new_object
= parse_object(new_sha1
);
521 if (!old_object
|| !new_object
||
522 old_object
->type
!= OBJ_COMMIT
||
523 new_object
->type
!= OBJ_COMMIT
) {
524 error("bad sha1 objects for %s", name
);
527 old_commit
= (struct commit
*)old_object
;
528 new_commit
= (struct commit
*)new_object
;
529 bases
= get_merge_bases(old_commit
, new_commit
, 1);
530 for (ent
= bases
; ent
; ent
= ent
->next
)
531 if (!hashcmp(old_sha1
, ent
->item
->object
.sha1
))
533 free_commit_list(bases
);
535 rp_error("denying non-fast-forward %s"
536 " (you should pull first)", name
);
537 return "non-fast-forward";
540 if (run_update_hook(cmd
)) {
541 rp_error("hook declined to update %s", name
);
542 return "hook declined";
545 if (is_null_sha1(new_sha1
)) {
546 if (!parse_object(old_sha1
)) {
548 if (ref_exists(name
)) {
549 rp_warning("Allowing deletion of corrupt ref.");
551 rp_warning("Deleting a non-existent ref.");
552 cmd
->did_not_exist
= 1;
555 if (delete_ref(namespaced_name
, old_sha1
, 0)) {
556 rp_error("failed to delete %s", name
);
557 return "failed to delete";
559 return NULL
; /* good */
562 lock
= lock_any_ref_for_update(namespaced_name
, old_sha1
, 0);
564 rp_error("failed to lock %s", name
);
565 return "failed to lock";
567 if (write_ref_sha1(lock
, new_sha1
, "push")) {
568 return "failed to write"; /* error() already called */
570 return NULL
; /* good */
574 static char update_post_hook
[] = "hooks/post-update";
576 static void run_update_post_hook(struct command
*commands
)
581 struct child_process proc
;
583 for (argc
= 0, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
584 if (cmd
->error_string
|| cmd
->did_not_exist
)
588 if (!argc
|| access(update_post_hook
, X_OK
) < 0)
590 argv
= xmalloc(sizeof(*argv
) * (2 + argc
));
591 argv
[0] = update_post_hook
;
593 for (argc
= 1, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
595 if (cmd
->error_string
|| cmd
->did_not_exist
)
597 p
= xmalloc(strlen(cmd
->ref_name
) + 1);
598 strcpy(p
, cmd
->ref_name
);
604 memset(&proc
, 0, sizeof(proc
));
606 proc
.stdout_to_stderr
= 1;
607 proc
.err
= use_sideband
? -1 : 0;
610 if (!start_command(&proc
)) {
612 copy_to_sideband(proc
.err
, -1, NULL
);
613 finish_command(&proc
);
617 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
619 struct strbuf buf
= STRBUF_INIT
;
620 const char *dst_name
;
621 struct string_list_item
*item
;
622 struct command
*dst_cmd
;
623 unsigned char sha1
[20];
624 char cmd_oldh
[41], cmd_newh
[41], dst_oldh
[41], dst_newh
[41];
627 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
628 dst_name
= resolve_ref(buf
.buf
, sha1
, 0, &flag
);
629 strbuf_release(&buf
);
631 if (!(flag
& REF_ISSYMREF
))
634 dst_name
= strip_namespace(dst_name
);
636 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
637 cmd
->skip_update
= 1;
638 cmd
->error_string
= "broken symref";
642 if ((item
= string_list_lookup(list
, dst_name
)) == NULL
)
645 cmd
->skip_update
= 1;
647 dst_cmd
= (struct command
*) item
->util
;
649 if (!hashcmp(cmd
->old_sha1
, dst_cmd
->old_sha1
) &&
650 !hashcmp(cmd
->new_sha1
, dst_cmd
->new_sha1
))
653 dst_cmd
->skip_update
= 1;
655 strcpy(cmd_oldh
, find_unique_abbrev(cmd
->old_sha1
, DEFAULT_ABBREV
));
656 strcpy(cmd_newh
, find_unique_abbrev(cmd
->new_sha1
, DEFAULT_ABBREV
));
657 strcpy(dst_oldh
, find_unique_abbrev(dst_cmd
->old_sha1
, DEFAULT_ABBREV
));
658 strcpy(dst_newh
, find_unique_abbrev(dst_cmd
->new_sha1
, DEFAULT_ABBREV
));
659 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
660 " its target '%s' (%s..%s)",
661 cmd
->ref_name
, cmd_oldh
, cmd_newh
,
662 dst_cmd
->ref_name
, dst_oldh
, dst_newh
);
664 cmd
->error_string
= dst_cmd
->error_string
=
665 "inconsistent aliased update";
668 static void check_aliased_updates(struct command
*commands
)
671 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
673 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
674 struct string_list_item
*item
=
675 string_list_append(&ref_list
, cmd
->ref_name
);
676 item
->util
= (void *)cmd
;
678 sort_string_list(&ref_list
);
680 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
681 check_aliased_update(cmd
, &ref_list
);
683 string_list_clear(&ref_list
, 0);
686 static int command_singleton_iterator(void *cb_data
, unsigned char sha1
[20])
688 struct command
**cmd_list
= cb_data
;
689 struct command
*cmd
= *cmd_list
;
692 return -1; /* end of list */
693 *cmd_list
= NULL
; /* this returns only one */
694 hashcpy(sha1
, cmd
->new_sha1
);
698 static void set_connectivity_errors(struct command
*commands
)
702 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
703 struct command
*singleton
= cmd
;
704 if (!check_everything_connected(command_singleton_iterator
,
707 cmd
->error_string
= "missing necessary objects";
711 static int iterate_receive_command_list(void *cb_data
, unsigned char sha1
[20])
713 struct command
**cmd_list
= cb_data
;
714 struct command
*cmd
= *cmd_list
;
717 return -1; /* end of list */
718 *cmd_list
= cmd
->next
;
719 hashcpy(sha1
, cmd
->new_sha1
);
723 static void execute_commands(struct command
*commands
, const char *unpacker_error
)
726 unsigned char sha1
[20];
728 if (unpacker_error
) {
729 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
730 cmd
->error_string
= "n/a (unpacker error)";
735 if (check_everything_connected(iterate_receive_command_list
,
737 set_connectivity_errors(commands
);
739 if (run_receive_hook(commands
, pre_receive_hook
, 0)) {
740 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
741 cmd
->error_string
= "pre-receive hook declined";
745 check_aliased_updates(commands
);
747 head_name
= resolve_ref("HEAD", sha1
, 0, NULL
);
749 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
750 if (!cmd
->skip_update
)
751 cmd
->error_string
= update(cmd
);
754 static struct command
*read_head_info(void)
756 struct command
*commands
= NULL
;
757 struct command
**p
= &commands
;
759 static char line
[1000];
760 unsigned char old_sha1
[20], new_sha1
[20];
765 len
= packet_read_line(0, line
, sizeof(line
));
768 if (line
[len
-1] == '\n')
773 get_sha1_hex(line
, old_sha1
) ||
774 get_sha1_hex(line
+ 41, new_sha1
))
775 die("protocol error: expected old/new/ref, got '%s'",
779 reflen
= strlen(refname
);
780 if (reflen
+ 82 < len
) {
781 if (strstr(refname
+ reflen
+ 1, "report-status"))
783 if (strstr(refname
+ reflen
+ 1, "side-band-64k"))
784 use_sideband
= LARGE_PACKET_MAX
;
786 cmd
= xcalloc(1, sizeof(struct command
) + len
- 80);
787 hashcpy(cmd
->old_sha1
, old_sha1
);
788 hashcpy(cmd
->new_sha1
, new_sha1
);
789 memcpy(cmd
->ref_name
, line
+ 82, len
- 81);
796 static const char *parse_pack_header(struct pack_header
*hdr
)
798 switch (read_pack_header(0, hdr
)) {
800 return "eof before pack header was fully read";
802 case PH_ERROR_PACK_SIGNATURE
:
803 return "protocol error (pack signature mismatch detected)";
805 case PH_ERROR_PROTOCOL
:
806 return "protocol error (pack version unsupported)";
809 return "unknown error in parse_pack_header";
816 static const char *pack_lockfile
;
818 static const char *unpack(void)
820 struct pack_header hdr
;
823 int fsck_objects
= (receive_fsck_objects
>= 0
824 ? receive_fsck_objects
825 : transfer_fsck_objects
>= 0
826 ? transfer_fsck_objects
829 hdr_err
= parse_pack_header(&hdr
);
832 snprintf(hdr_arg
, sizeof(hdr_arg
),
833 "--pack_header=%"PRIu32
",%"PRIu32
,
834 ntohl(hdr
.hdr_version
), ntohl(hdr
.hdr_entries
));
836 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
838 const char *unpacker
[4];
839 unpacker
[i
++] = "unpack-objects";
841 unpacker
[i
++] = "--strict";
842 unpacker
[i
++] = hdr_arg
;
843 unpacker
[i
++] = NULL
;
844 code
= run_command_v_opt(unpacker
, RUN_GIT_CMD
);
847 return "unpack-objects abnormal exit";
849 const char *keeper
[7];
850 int s
, status
, i
= 0;
852 struct child_process ip
;
854 s
= sprintf(keep_arg
, "--keep=receive-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
855 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
856 strcpy(keep_arg
+ s
, "localhost");
858 keeper
[i
++] = "index-pack";
859 keeper
[i
++] = "--stdin";
861 keeper
[i
++] = "--strict";
862 keeper
[i
++] = "--fix-thin";
863 keeper
[i
++] = hdr_arg
;
864 keeper
[i
++] = keep_arg
;
866 memset(&ip
, 0, sizeof(ip
));
870 status
= start_command(&ip
);
872 return "index-pack fork failed";
874 pack_lockfile
= index_pack_lockfile(ip
.out
);
876 status
= finish_command(&ip
);
878 reprepare_packed_git();
881 return "index-pack abnormal exit";
885 static void report(struct command
*commands
, const char *unpack_status
)
888 struct strbuf buf
= STRBUF_INIT
;
890 packet_buf_write(&buf
, "unpack %s\n",
891 unpack_status
? unpack_status
: "ok");
892 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
893 if (!cmd
->error_string
)
894 packet_buf_write(&buf
, "ok %s\n",
897 packet_buf_write(&buf
, "ng %s %s\n",
898 cmd
->ref_name
, cmd
->error_string
);
900 packet_buf_flush(&buf
);
903 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
905 safe_write(1, buf
.buf
, buf
.len
);
906 strbuf_release(&buf
);
909 static int delete_only(struct command
*commands
)
912 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
913 if (!is_null_sha1(cmd
->new_sha1
))
919 static void add_one_alternate_sha1(const unsigned char sha1
[20], void *unused
)
921 add_extra_ref(".have", sha1
, 0);
924 static void collect_one_alternate_ref(const struct ref
*ref
, void *data
)
926 struct sha1_array
*sa
= data
;
927 sha1_array_append(sa
, ref
->old_sha1
);
930 static void add_alternate_refs(void)
932 struct sha1_array sa
= SHA1_ARRAY_INIT
;
933 for_each_alternate_ref(collect_one_alternate_ref
, &sa
);
934 sha1_array_for_each_unique(&sa
, add_one_alternate_sha1
, NULL
);
935 sha1_array_clear(&sa
);
938 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
940 int advertise_refs
= 0;
941 int stateless_rpc
= 0;
944 struct command
*commands
;
946 packet_trace_identity("receive-pack");
949 for (i
= 1; i
< argc
; i
++) {
950 const char *arg
= *argv
++;
953 if (!strcmp(arg
, "--advertise-refs")) {
957 if (!strcmp(arg
, "--stateless-rpc")) {
962 usage(receive_pack_usage
);
965 usage(receive_pack_usage
);
969 usage(receive_pack_usage
);
973 if (!enter_repo(dir
, 0))
974 die("'%s' does not appear to be a git repository", dir
);
976 if (is_repository_shallow())
977 die("attempt to push into a shallow repository");
979 git_config(receive_pack_config
, NULL
);
981 if (0 <= transfer_unpack_limit
)
982 unpack_limit
= transfer_unpack_limit
;
983 else if (0 <= receive_unpack_limit
)
984 unpack_limit
= receive_unpack_limit
;
986 if (advertise_refs
|| !stateless_rpc
) {
987 add_alternate_refs();
997 if ((commands
= read_head_info()) != NULL
) {
998 const char *unpack_status
= NULL
;
1000 if (!delete_only(commands
))
1001 unpack_status
= unpack();
1002 execute_commands(commands
, unpack_status
);
1004 unlink_or_warn(pack_lockfile
);
1006 report(commands
, unpack_status
);
1007 run_receive_hook(commands
, post_receive_hook
, 1);
1008 run_update_post_hook(commands
);
1010 const char *argv_gc_auto
[] = {
1011 "gc", "--auto", "--quiet", NULL
,
1013 run_command_v_opt(argv_gc_auto
, RUN_GIT_CMD
);
1015 if (auto_update_server_info
)
1016 update_server_info(0);