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", "--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
;
691 if (!cmd
|| is_null_sha1(cmd
->new_sha1
))
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 if (!is_null_sha1(cmd
->new_sha1
)) {
718 hashcpy(sha1
, cmd
->new_sha1
);
719 *cmd_list
= cmd
->next
;
725 return -1; /* end of list */
728 static void execute_commands(struct command
*commands
, const char *unpacker_error
)
731 unsigned char sha1
[20];
733 if (unpacker_error
) {
734 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
735 cmd
->error_string
= "n/a (unpacker error)";
740 if (check_everything_connected(iterate_receive_command_list
,
742 set_connectivity_errors(commands
);
744 if (run_receive_hook(commands
, pre_receive_hook
, 0)) {
745 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
746 cmd
->error_string
= "pre-receive hook declined";
750 check_aliased_updates(commands
);
752 free((char*)head_name
);
753 head_name
= resolve_ref("HEAD", sha1
, 0, NULL
);
755 head_name
= xstrdup(head_name
);
757 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
758 if (!cmd
->skip_update
)
759 cmd
->error_string
= update(cmd
);
762 static struct command
*read_head_info(void)
764 struct command
*commands
= NULL
;
765 struct command
**p
= &commands
;
767 static char line
[1000];
768 unsigned char old_sha1
[20], new_sha1
[20];
773 len
= packet_read_line(0, line
, sizeof(line
));
776 if (line
[len
-1] == '\n')
781 get_sha1_hex(line
, old_sha1
) ||
782 get_sha1_hex(line
+ 41, new_sha1
))
783 die("protocol error: expected old/new/ref, got '%s'",
787 reflen
= strlen(refname
);
788 if (reflen
+ 82 < len
) {
789 if (strstr(refname
+ reflen
+ 1, "report-status"))
791 if (strstr(refname
+ reflen
+ 1, "side-band-64k"))
792 use_sideband
= LARGE_PACKET_MAX
;
794 cmd
= xcalloc(1, sizeof(struct command
) + len
- 80);
795 hashcpy(cmd
->old_sha1
, old_sha1
);
796 hashcpy(cmd
->new_sha1
, new_sha1
);
797 memcpy(cmd
->ref_name
, line
+ 82, len
- 81);
804 static const char *parse_pack_header(struct pack_header
*hdr
)
806 switch (read_pack_header(0, hdr
)) {
808 return "eof before pack header was fully read";
810 case PH_ERROR_PACK_SIGNATURE
:
811 return "protocol error (pack signature mismatch detected)";
813 case PH_ERROR_PROTOCOL
:
814 return "protocol error (pack version unsupported)";
817 return "unknown error in parse_pack_header";
824 static const char *pack_lockfile
;
826 static const char *unpack(void)
828 struct pack_header hdr
;
831 int fsck_objects
= (receive_fsck_objects
>= 0
832 ? receive_fsck_objects
833 : transfer_fsck_objects
>= 0
834 ? transfer_fsck_objects
837 hdr_err
= parse_pack_header(&hdr
);
840 snprintf(hdr_arg
, sizeof(hdr_arg
),
841 "--pack_header=%"PRIu32
",%"PRIu32
,
842 ntohl(hdr
.hdr_version
), ntohl(hdr
.hdr_entries
));
844 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
846 const char *unpacker
[4];
847 unpacker
[i
++] = "unpack-objects";
849 unpacker
[i
++] = "--strict";
850 unpacker
[i
++] = hdr_arg
;
851 unpacker
[i
++] = NULL
;
852 code
= run_command_v_opt(unpacker
, RUN_GIT_CMD
);
855 return "unpack-objects abnormal exit";
857 const char *keeper
[7];
858 int s
, status
, i
= 0;
860 struct child_process ip
;
862 s
= sprintf(keep_arg
, "--keep=receive-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
863 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
864 strcpy(keep_arg
+ s
, "localhost");
866 keeper
[i
++] = "index-pack";
867 keeper
[i
++] = "--stdin";
869 keeper
[i
++] = "--strict";
870 keeper
[i
++] = "--fix-thin";
871 keeper
[i
++] = hdr_arg
;
872 keeper
[i
++] = keep_arg
;
874 memset(&ip
, 0, sizeof(ip
));
878 status
= start_command(&ip
);
880 return "index-pack fork failed";
882 pack_lockfile
= index_pack_lockfile(ip
.out
);
884 status
= finish_command(&ip
);
886 reprepare_packed_git();
889 return "index-pack abnormal exit";
893 static void report(struct command
*commands
, const char *unpack_status
)
896 struct strbuf buf
= STRBUF_INIT
;
898 packet_buf_write(&buf
, "unpack %s\n",
899 unpack_status
? unpack_status
: "ok");
900 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
901 if (!cmd
->error_string
)
902 packet_buf_write(&buf
, "ok %s\n",
905 packet_buf_write(&buf
, "ng %s %s\n",
906 cmd
->ref_name
, cmd
->error_string
);
908 packet_buf_flush(&buf
);
911 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
913 safe_write(1, buf
.buf
, buf
.len
);
914 strbuf_release(&buf
);
917 static int delete_only(struct command
*commands
)
920 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
921 if (!is_null_sha1(cmd
->new_sha1
))
927 static void add_one_alternate_sha1(const unsigned char sha1
[20], void *unused
)
929 add_extra_ref(".have", sha1
, 0);
932 static void collect_one_alternate_ref(const struct ref
*ref
, void *data
)
934 struct sha1_array
*sa
= data
;
935 sha1_array_append(sa
, ref
->old_sha1
);
938 static void add_alternate_refs(void)
940 struct sha1_array sa
= SHA1_ARRAY_INIT
;
941 for_each_alternate_ref(collect_one_alternate_ref
, &sa
);
942 sha1_array_for_each_unique(&sa
, add_one_alternate_sha1
, NULL
);
943 sha1_array_clear(&sa
);
946 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
948 int advertise_refs
= 0;
949 int stateless_rpc
= 0;
952 struct command
*commands
;
954 packet_trace_identity("receive-pack");
957 for (i
= 1; i
< argc
; i
++) {
958 const char *arg
= *argv
++;
961 if (!strcmp(arg
, "--advertise-refs")) {
965 if (!strcmp(arg
, "--stateless-rpc")) {
970 usage(receive_pack_usage
);
973 usage(receive_pack_usage
);
977 usage(receive_pack_usage
);
981 if (!enter_repo(dir
, 0))
982 die("'%s' does not appear to be a git repository", dir
);
984 if (is_repository_shallow())
985 die("attempt to push into a shallow repository");
987 git_config(receive_pack_config
, NULL
);
989 if (0 <= transfer_unpack_limit
)
990 unpack_limit
= transfer_unpack_limit
;
991 else if (0 <= receive_unpack_limit
)
992 unpack_limit
= receive_unpack_limit
;
994 if (advertise_refs
|| !stateless_rpc
) {
995 add_alternate_refs();
1005 if ((commands
= read_head_info()) != NULL
) {
1006 const char *unpack_status
= NULL
;
1008 if (!delete_only(commands
))
1009 unpack_status
= unpack();
1010 execute_commands(commands
, unpack_status
);
1012 unlink_or_warn(pack_lockfile
);
1014 report(commands
, unpack_status
);
1015 run_receive_hook(commands
, post_receive_hook
, 1);
1016 run_update_post_hook(commands
);
1018 const char *argv_gc_auto
[] = {
1019 "gc", "--auto", "--quiet", NULL
,
1021 run_command_v_opt(argv_gc_auto
, RUN_GIT_CMD
);
1023 if (auto_update_server_info
)
1024 update_server_info(0);