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
;
39 static int prefer_ofs_delta
= 1;
40 static int auto_update_server_info
;
41 static int auto_gc
= 1;
42 static const char *head_name
;
43 static void *head_name_to_free
;
44 static int sent_capabilities
;
46 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
49 if (!strcasecmp(value
, "ignore"))
51 if (!strcasecmp(value
, "warn"))
53 if (!strcasecmp(value
, "refuse"))
56 if (git_config_bool(var
, value
))
61 static int receive_pack_config(const char *var
, const char *value
, void *cb
)
63 if (strcmp(var
, "receive.denydeletes") == 0) {
64 deny_deletes
= git_config_bool(var
, value
);
68 if (strcmp(var
, "receive.denynonfastforwards") == 0) {
69 deny_non_fast_forwards
= git_config_bool(var
, value
);
73 if (strcmp(var
, "receive.unpacklimit") == 0) {
74 receive_unpack_limit
= git_config_int(var
, value
);
78 if (strcmp(var
, "transfer.unpacklimit") == 0) {
79 transfer_unpack_limit
= git_config_int(var
, value
);
83 if (strcmp(var
, "receive.fsckobjects") == 0) {
84 receive_fsck_objects
= git_config_bool(var
, value
);
88 if (strcmp(var
, "transfer.fsckobjects") == 0) {
89 transfer_fsck_objects
= git_config_bool(var
, value
);
93 if (!strcmp(var
, "receive.denycurrentbranch")) {
94 if (value
&& !strcasecmp(value
, "updateinstead"))
95 deny_current_branch
= DENY_UPDATE_INSTEAD
;
96 else if (value
&& !strcasecmp(value
, "detachinstead"))
97 deny_current_branch
= DENY_DETACH_INSTEAD
;
99 deny_current_branch
= parse_deny_action(var
, value
);
103 if (strcmp(var
, "receive.denydeletecurrent") == 0) {
104 deny_delete_current
= parse_deny_action(var
, value
);
108 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
109 prefer_ofs_delta
= git_config_bool(var
, value
);
113 if (strcmp(var
, "receive.updateserverinfo") == 0) {
114 auto_update_server_info
= git_config_bool(var
, value
);
118 if (strcmp(var
, "receive.autogc") == 0) {
119 auto_gc
= git_config_bool(var
, value
);
123 return git_default_config(var
, value
, cb
);
126 static void show_ref(const char *path
, const unsigned char *sha1
)
128 if (sent_capabilities
)
129 packet_write(1, "%s %s\n", sha1_to_hex(sha1
), path
);
131 packet_write(1, "%s %s%c%s%s\n",
132 sha1_to_hex(sha1
), path
, 0,
133 " report-status delete-refs side-band-64k quiet",
134 prefer_ofs_delta
? " ofs-delta" : "");
135 sent_capabilities
= 1;
138 static int show_ref_cb(const char *path
, const unsigned char *sha1
, int flag
, void *unused
)
140 path
= strip_namespace(path
);
142 * Advertise refs outside our current namespace as ".have"
143 * refs, so that the client can use them to minimize data
144 * transfer but will otherwise ignore them. This happens to
145 * cover ".have" that are thrown in by add_one_alternate_ref()
146 * to mark histories that are complete in our alternates as
151 show_ref(path
, sha1
);
155 static void show_one_alternate_sha1(const unsigned char sha1
[20], void *unused
)
157 show_ref(".have", sha1
);
160 static void collect_one_alternate_ref(const struct ref
*ref
, void *data
)
162 struct sha1_array
*sa
= data
;
163 sha1_array_append(sa
, ref
->old_sha1
);
166 static void write_head_info(void)
168 struct sha1_array sa
= SHA1_ARRAY_INIT
;
169 for_each_alternate_ref(collect_one_alternate_ref
, &sa
);
170 sha1_array_for_each_unique(&sa
, show_one_alternate_sha1
, NULL
);
171 sha1_array_clear(&sa
);
172 for_each_ref(show_ref_cb
, NULL
);
173 if (!sent_capabilities
)
174 show_ref("capabilities^{}", null_sha1
);
181 struct command
*next
;
182 const char *error_string
;
183 unsigned int skip_update
:1,
185 unsigned char old_sha1
[20];
186 unsigned char new_sha1
[20];
187 char ref_name
[FLEX_ARRAY
]; /* more */
190 static const char pre_receive_hook
[] = "hooks/pre-receive";
191 static const char post_receive_hook
[] = "hooks/post-receive";
193 static void rp_error(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
194 static void rp_warning(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
196 static void report_message(const char *prefix
, const char *err
, va_list params
)
198 int sz
= strlen(prefix
);
201 strncpy(msg
, prefix
, sz
);
202 sz
+= vsnprintf(msg
+ sz
, sizeof(msg
) - sz
, err
, params
);
203 if (sz
> (sizeof(msg
) - 1))
204 sz
= sizeof(msg
) - 1;
208 send_sideband(1, 2, msg
, sz
, use_sideband
);
213 static void rp_warning(const char *err
, ...)
216 va_start(params
, err
);
217 report_message("warning: ", err
, params
);
221 static void rp_error(const char *err
, ...)
224 va_start(params
, err
);
225 report_message("error: ", err
, params
);
229 static int copy_to_sideband(int in
, int out
, void *arg
)
233 ssize_t sz
= xread(in
, data
, sizeof(data
));
236 send_sideband(1, 2, data
, sz
, use_sideband
);
242 typedef int (*feed_fn
)(void *, const char **, size_t *);
243 static int run_and_feed_hook(const char *hook_name
, feed_fn feed
, void *feed_state
)
245 struct child_process proc
;
250 if (access(hook_name
, X_OK
) < 0)
256 memset(&proc
, 0, sizeof(proc
));
259 proc
.stdout_to_stderr
= 1;
262 memset(&muxer
, 0, sizeof(muxer
));
263 muxer
.proc
= copy_to_sideband
;
265 code
= start_async(&muxer
);
271 code
= start_command(&proc
);
274 finish_async(&muxer
);
281 if (feed(feed_state
, &buf
, &n
))
283 if (write_in_full(proc
.in
, buf
, n
) != n
)
288 finish_async(&muxer
);
289 return finish_command(&proc
);
292 struct receive_hook_feed_state
{
298 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
300 struct receive_hook_feed_state
*state
= state_
;
301 struct command
*cmd
= state
->cmd
;
304 state
->skip_broken
&& (cmd
->error_string
|| cmd
->did_not_exist
))
308 strbuf_reset(&state
->buf
);
309 strbuf_addf(&state
->buf
, "%s %s %s\n",
310 sha1_to_hex(cmd
->old_sha1
), sha1_to_hex(cmd
->new_sha1
),
312 state
->cmd
= cmd
->next
;
314 *bufp
= state
->buf
.buf
;
315 *sizep
= state
->buf
.len
;
320 static int run_receive_hook(struct command
*commands
, const char *hook_name
,
323 struct receive_hook_feed_state state
;
326 strbuf_init(&state
.buf
, 0);
327 state
.cmd
= commands
;
328 state
.skip_broken
= skip_broken
;
329 if (feed_receive_hook(&state
, NULL
, NULL
))
331 state
.cmd
= commands
;
332 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
333 strbuf_release(&state
.buf
);
337 static int run_update_hook(struct command
*cmd
)
339 static const char update_hook
[] = "hooks/update";
341 struct child_process proc
;
344 if (access(update_hook
, X_OK
) < 0)
347 argv
[0] = update_hook
;
348 argv
[1] = cmd
->ref_name
;
349 argv
[2] = sha1_to_hex(cmd
->old_sha1
);
350 argv
[3] = sha1_to_hex(cmd
->new_sha1
);
353 memset(&proc
, 0, sizeof(proc
));
355 proc
.stdout_to_stderr
= 1;
356 proc
.err
= use_sideband
? -1 : 0;
359 code
= start_command(&proc
);
363 copy_to_sideband(proc
.err
, -1, NULL
);
364 return finish_command(&proc
);
367 static int is_ref_checked_out(const char *ref
)
369 if (is_bare_repository())
374 return !strcmp(head_name
, ref
);
377 static char *refuse_unconfigured_deny_msg
[] = {
378 "By default, updating the current branch in a non-bare repository",
379 "is denied, because it will make the index and work tree inconsistent",
380 "with what you pushed, and will require 'git reset --hard' to match",
381 "the work tree to HEAD.",
383 "You can set 'receive.denyCurrentBranch' configuration variable to",
384 "'ignore' or 'warn' in the remote repository to allow pushing into",
385 "its current branch; however, this is not recommended unless you",
386 "arranged to update its work tree to match what you pushed in some",
389 "To squelch this message and still keep the default behaviour, set",
390 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
393 static void refuse_unconfigured_deny(void)
396 for (i
= 0; i
< ARRAY_SIZE(refuse_unconfigured_deny_msg
); i
++)
397 rp_error("%s", refuse_unconfigured_deny_msg
[i
]);
400 static char *refuse_unconfigured_deny_delete_current_msg
[] = {
401 "By default, deleting the current branch is denied, because the next",
402 "'git clone' won't result in any file checked out, causing confusion.",
404 "You can set 'receive.denyDeleteCurrent' configuration variable to",
405 "'warn' or 'ignore' in the remote repository to allow deleting the",
406 "current branch, with or without a warning message.",
408 "To squelch this message, you can set it to 'refuse'."
411 static void refuse_unconfigured_deny_delete_current(void)
415 i
< ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg
);
417 rp_error("%s", refuse_unconfigured_deny_delete_current_msg
[i
]);
420 static void merge_worktree(unsigned char *sha1
)
422 const char *update_refresh
[] = {
423 "update-index", "--refresh", NULL
425 const char *read_tree
[] = {
426 "read-tree", "-u", "-m", sha1_to_hex(sha1
), NULL
428 struct child_process child
;
429 struct strbuf git_env
= STRBUF_INIT
;
432 if (is_bare_repository())
433 die ("denyCurrentBranch = updateInstead needs a worktree");
435 strbuf_addf(&git_env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
436 env
[0] = git_env
.buf
;
439 memset(&child
, 0, sizeof(child
));
440 child
.argv
= update_refresh
;
442 child
.dir
= git_work_tree_cfg
? git_work_tree_cfg
: "..";
443 child
.stdout_to_stderr
= 1;
445 if (run_command(&child
))
446 die ("Could not refresh the index");
448 child
.argv
= read_tree
;
451 child
.stdout_to_stderr
= 0;
452 if (run_command(&child
))
453 die ("Could not merge working tree with new HEAD. Good luck.");
455 strbuf_release(&git_env
);
458 static const char *update(struct command
*cmd
)
460 const char *name
= cmd
->ref_name
;
461 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
462 const char *namespaced_name
;
463 unsigned char *old_sha1
= cmd
->old_sha1
;
464 unsigned char *new_sha1
= cmd
->new_sha1
;
465 struct ref_lock
*lock
;
467 /* only refs/... are allowed */
468 if (prefixcmp(name
, "refs/") || check_refname_format(name
+ 5, 0)) {
469 rp_error("refusing to create funny ref '%s' remotely", name
);
470 return "funny refname";
473 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
474 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
476 if (is_ref_checked_out(namespaced_name
)) {
477 switch (deny_current_branch
) {
481 rp_warning("updating the current branch");
484 case DENY_UNCONFIGURED
:
485 rp_error("refusing to update checked out branch: %s", name
);
486 if (deny_current_branch
== DENY_UNCONFIGURED
)
487 refuse_unconfigured_deny();
488 return "branch is currently checked out";
489 case DENY_UPDATE_INSTEAD
:
490 merge_worktree(new_sha1
);
492 case DENY_DETACH_INSTEAD
:
493 update_ref("push into current branch (detach)", "HEAD",
494 old_sha1
, NULL
, REF_NODEREF
, DIE_ON_ERR
);
499 if (!is_null_sha1(new_sha1
) && !has_sha1_file(new_sha1
)) {
500 error("unpack should have generated %s, "
501 "but I can't find it!", sha1_to_hex(new_sha1
));
505 if (!is_null_sha1(old_sha1
) && is_null_sha1(new_sha1
)) {
506 if (deny_deletes
&& !prefixcmp(name
, "refs/heads/")) {
507 rp_error("denying ref deletion for %s", name
);
508 return "deletion prohibited";
511 if (!strcmp(namespaced_name
, head_name
)) {
512 switch (deny_delete_current
) {
516 rp_warning("deleting the current branch");
519 case DENY_UNCONFIGURED
:
520 if (deny_delete_current
== DENY_UNCONFIGURED
)
521 refuse_unconfigured_deny_delete_current();
522 rp_error("refusing to delete the current branch: %s", name
);
523 return "deletion of the current branch prohibited";
525 die ("Invalid denyDeleteCurrent setting");
530 if (deny_non_fast_forwards
&& !is_null_sha1(new_sha1
) &&
531 !is_null_sha1(old_sha1
) &&
532 !prefixcmp(name
, "refs/heads/")) {
533 struct object
*old_object
, *new_object
;
534 struct commit
*old_commit
, *new_commit
;
535 struct commit_list
*bases
, *ent
;
537 old_object
= parse_object(old_sha1
);
538 new_object
= parse_object(new_sha1
);
540 if (!old_object
|| !new_object
||
541 old_object
->type
!= OBJ_COMMIT
||
542 new_object
->type
!= OBJ_COMMIT
) {
543 error("bad sha1 objects for %s", name
);
546 old_commit
= (struct commit
*)old_object
;
547 new_commit
= (struct commit
*)new_object
;
548 bases
= get_merge_bases(old_commit
, new_commit
, 1);
549 for (ent
= bases
; ent
; ent
= ent
->next
)
550 if (!hashcmp(old_sha1
, ent
->item
->object
.sha1
))
552 free_commit_list(bases
);
554 rp_error("denying non-fast-forward %s"
555 " (you should pull first)", name
);
556 return "non-fast-forward";
559 if (run_update_hook(cmd
)) {
560 rp_error("hook declined to update %s", name
);
561 return "hook declined";
564 if (is_null_sha1(new_sha1
)) {
565 if (!parse_object(old_sha1
)) {
567 if (ref_exists(name
)) {
568 rp_warning("Allowing deletion of corrupt ref.");
570 rp_warning("Deleting a non-existent ref.");
571 cmd
->did_not_exist
= 1;
574 if (delete_ref(namespaced_name
, old_sha1
, 0)) {
575 rp_error("failed to delete %s", name
);
576 return "failed to delete";
578 return NULL
; /* good */
581 lock
= lock_any_ref_for_update(namespaced_name
, old_sha1
, 0);
583 rp_error("failed to lock %s", name
);
584 return "failed to lock";
586 if (write_ref_sha1(lock
, new_sha1
, "push")) {
587 return "failed to write"; /* error() already called */
589 return NULL
; /* good */
593 static char update_post_hook
[] = "hooks/post-update";
595 static void run_update_post_hook(struct command
*commands
)
600 struct child_process proc
;
602 for (argc
= 0, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
603 if (cmd
->error_string
|| cmd
->did_not_exist
)
607 if (!argc
|| access(update_post_hook
, X_OK
) < 0)
609 argv
= xmalloc(sizeof(*argv
) * (2 + argc
));
610 argv
[0] = update_post_hook
;
612 for (argc
= 1, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
614 if (cmd
->error_string
|| cmd
->did_not_exist
)
616 p
= xmalloc(strlen(cmd
->ref_name
) + 1);
617 strcpy(p
, cmd
->ref_name
);
623 memset(&proc
, 0, sizeof(proc
));
625 proc
.stdout_to_stderr
= 1;
626 proc
.err
= use_sideband
? -1 : 0;
629 if (!start_command(&proc
)) {
631 copy_to_sideband(proc
.err
, -1, NULL
);
632 finish_command(&proc
);
636 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
638 struct strbuf buf
= STRBUF_INIT
;
639 const char *dst_name
;
640 struct string_list_item
*item
;
641 struct command
*dst_cmd
;
642 unsigned char sha1
[20];
643 char cmd_oldh
[41], cmd_newh
[41], dst_oldh
[41], dst_newh
[41];
646 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
647 dst_name
= resolve_ref_unsafe(buf
.buf
, sha1
, 0, &flag
);
648 strbuf_release(&buf
);
650 if (!(flag
& REF_ISSYMREF
))
653 dst_name
= strip_namespace(dst_name
);
655 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
656 cmd
->skip_update
= 1;
657 cmd
->error_string
= "broken symref";
661 if ((item
= string_list_lookup(list
, dst_name
)) == NULL
)
664 cmd
->skip_update
= 1;
666 dst_cmd
= (struct command
*) item
->util
;
668 if (!hashcmp(cmd
->old_sha1
, dst_cmd
->old_sha1
) &&
669 !hashcmp(cmd
->new_sha1
, dst_cmd
->new_sha1
))
672 dst_cmd
->skip_update
= 1;
674 strcpy(cmd_oldh
, find_unique_abbrev(cmd
->old_sha1
, DEFAULT_ABBREV
));
675 strcpy(cmd_newh
, find_unique_abbrev(cmd
->new_sha1
, DEFAULT_ABBREV
));
676 strcpy(dst_oldh
, find_unique_abbrev(dst_cmd
->old_sha1
, DEFAULT_ABBREV
));
677 strcpy(dst_newh
, find_unique_abbrev(dst_cmd
->new_sha1
, DEFAULT_ABBREV
));
678 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
679 " its target '%s' (%s..%s)",
680 cmd
->ref_name
, cmd_oldh
, cmd_newh
,
681 dst_cmd
->ref_name
, dst_oldh
, dst_newh
);
683 cmd
->error_string
= dst_cmd
->error_string
=
684 "inconsistent aliased update";
687 static void check_aliased_updates(struct command
*commands
)
690 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
692 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
693 struct string_list_item
*item
=
694 string_list_append(&ref_list
, cmd
->ref_name
);
695 item
->util
= (void *)cmd
;
697 sort_string_list(&ref_list
);
699 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
700 check_aliased_update(cmd
, &ref_list
);
702 string_list_clear(&ref_list
, 0);
705 static int command_singleton_iterator(void *cb_data
, unsigned char sha1
[20])
707 struct command
**cmd_list
= cb_data
;
708 struct command
*cmd
= *cmd_list
;
710 if (!cmd
|| is_null_sha1(cmd
->new_sha1
))
711 return -1; /* end of list */
712 *cmd_list
= NULL
; /* this returns only one */
713 hashcpy(sha1
, cmd
->new_sha1
);
717 static void set_connectivity_errors(struct command
*commands
)
721 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
722 struct command
*singleton
= cmd
;
723 if (!check_everything_connected(command_singleton_iterator
,
726 cmd
->error_string
= "missing necessary objects";
730 static int iterate_receive_command_list(void *cb_data
, unsigned char sha1
[20])
732 struct command
**cmd_list
= cb_data
;
733 struct command
*cmd
= *cmd_list
;
736 if (!is_null_sha1(cmd
->new_sha1
)) {
737 hashcpy(sha1
, cmd
->new_sha1
);
738 *cmd_list
= cmd
->next
;
744 return -1; /* end of list */
747 static void execute_commands(struct command
*commands
, const char *unpacker_error
)
750 unsigned char sha1
[20];
752 if (unpacker_error
) {
753 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
754 cmd
->error_string
= "n/a (unpacker error)";
759 if (check_everything_connected(iterate_receive_command_list
,
761 set_connectivity_errors(commands
);
763 if (run_receive_hook(commands
, pre_receive_hook
, 0)) {
764 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
765 cmd
->error_string
= "pre-receive hook declined";
769 check_aliased_updates(commands
);
771 free(head_name_to_free
);
772 head_name
= head_name_to_free
= resolve_refdup("HEAD", sha1
, 0, NULL
);
774 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
775 if (!cmd
->skip_update
)
776 cmd
->error_string
= update(cmd
);
779 static struct command
*read_head_info(void)
781 struct command
*commands
= NULL
;
782 struct command
**p
= &commands
;
784 static char line
[1000];
785 unsigned char old_sha1
[20], new_sha1
[20];
790 len
= packet_read_line(0, line
, sizeof(line
));
793 if (line
[len
-1] == '\n')
798 get_sha1_hex(line
, old_sha1
) ||
799 get_sha1_hex(line
+ 41, new_sha1
))
800 die("protocol error: expected old/new/ref, got '%s'",
804 reflen
= strlen(refname
);
805 if (reflen
+ 82 < len
) {
806 const char *feature_list
= refname
+ reflen
+ 1;
807 if (parse_feature_request(feature_list
, "report-status"))
809 if (parse_feature_request(feature_list
, "side-band-64k"))
810 use_sideband
= LARGE_PACKET_MAX
;
811 if (parse_feature_request(feature_list
, "quiet"))
814 cmd
= xcalloc(1, sizeof(struct command
) + len
- 80);
815 hashcpy(cmd
->old_sha1
, old_sha1
);
816 hashcpy(cmd
->new_sha1
, new_sha1
);
817 memcpy(cmd
->ref_name
, line
+ 82, len
- 81);
824 static const char *parse_pack_header(struct pack_header
*hdr
)
826 switch (read_pack_header(0, hdr
)) {
828 return "eof before pack header was fully read";
830 case PH_ERROR_PACK_SIGNATURE
:
831 return "protocol error (pack signature mismatch detected)";
833 case PH_ERROR_PROTOCOL
:
834 return "protocol error (pack version unsupported)";
837 return "unknown error in parse_pack_header";
844 static const char *pack_lockfile
;
846 static const char *unpack(void)
848 struct pack_header hdr
;
851 int fsck_objects
= (receive_fsck_objects
>= 0
852 ? receive_fsck_objects
853 : transfer_fsck_objects
>= 0
854 ? transfer_fsck_objects
857 hdr_err
= parse_pack_header(&hdr
);
860 snprintf(hdr_arg
, sizeof(hdr_arg
),
861 "--pack_header=%"PRIu32
",%"PRIu32
,
862 ntohl(hdr
.hdr_version
), ntohl(hdr
.hdr_entries
));
864 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
866 const char *unpacker
[5];
867 unpacker
[i
++] = "unpack-objects";
869 unpacker
[i
++] = "-q";
871 unpacker
[i
++] = "--strict";
872 unpacker
[i
++] = hdr_arg
;
873 unpacker
[i
++] = NULL
;
874 code
= run_command_v_opt(unpacker
, RUN_GIT_CMD
);
877 return "unpack-objects abnormal exit";
879 const char *keeper
[7];
880 int s
, status
, i
= 0;
882 struct child_process ip
;
884 s
= sprintf(keep_arg
, "--keep=receive-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
885 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
886 strcpy(keep_arg
+ s
, "localhost");
888 keeper
[i
++] = "index-pack";
889 keeper
[i
++] = "--stdin";
891 keeper
[i
++] = "--strict";
892 keeper
[i
++] = "--fix-thin";
893 keeper
[i
++] = hdr_arg
;
894 keeper
[i
++] = keep_arg
;
896 memset(&ip
, 0, sizeof(ip
));
900 status
= start_command(&ip
);
902 return "index-pack fork failed";
904 pack_lockfile
= index_pack_lockfile(ip
.out
);
906 status
= finish_command(&ip
);
908 reprepare_packed_git();
911 return "index-pack abnormal exit";
915 static void report(struct command
*commands
, const char *unpack_status
)
918 struct strbuf buf
= STRBUF_INIT
;
920 packet_buf_write(&buf
, "unpack %s\n",
921 unpack_status
? unpack_status
: "ok");
922 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
923 if (!cmd
->error_string
)
924 packet_buf_write(&buf
, "ok %s\n",
927 packet_buf_write(&buf
, "ng %s %s\n",
928 cmd
->ref_name
, cmd
->error_string
);
930 packet_buf_flush(&buf
);
933 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
935 safe_write(1, buf
.buf
, buf
.len
);
936 strbuf_release(&buf
);
939 static int delete_only(struct command
*commands
)
942 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
943 if (!is_null_sha1(cmd
->new_sha1
))
949 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
951 int advertise_refs
= 0;
952 int stateless_rpc
= 0;
955 struct command
*commands
;
957 packet_trace_identity("receive-pack");
960 for (i
= 1; i
< argc
; i
++) {
961 const char *arg
= *argv
++;
964 if (!strcmp(arg
, "--quiet")) {
969 if (!strcmp(arg
, "--advertise-refs")) {
973 if (!strcmp(arg
, "--stateless-rpc")) {
978 usage(receive_pack_usage
);
981 usage(receive_pack_usage
);
985 usage(receive_pack_usage
);
989 if (!enter_repo(dir
, 0))
990 die("'%s' does not appear to be a git repository", dir
);
992 if (is_repository_shallow())
993 die("attempt to push into a shallow repository");
995 git_config(receive_pack_config
, NULL
);
997 if (0 <= transfer_unpack_limit
)
998 unpack_limit
= transfer_unpack_limit
;
999 else if (0 <= receive_unpack_limit
)
1000 unpack_limit
= receive_unpack_limit
;
1002 if (advertise_refs
|| !stateless_rpc
) {
1008 if ((commands
= read_head_info()) != NULL
) {
1009 const char *unpack_status
= NULL
;
1011 if (!delete_only(commands
))
1012 unpack_status
= unpack();
1013 execute_commands(commands
, unpack_status
);
1015 unlink_or_warn(pack_lockfile
);
1017 report(commands
, unpack_status
);
1018 run_receive_hook(commands
, post_receive_hook
, 1);
1019 run_update_post_hook(commands
);
1021 const char *argv_gc_auto
[] = {
1022 "gc", "--auto", "--quiet", NULL
,
1024 run_command_v_opt(argv_gc_auto
, RUN_GIT_CMD
);
1026 if (auto_update_server_info
)
1027 update_server_info(0);