6 #include "run-command.h"
12 #include "transport.h"
13 #include "string-list.h"
14 #include "sha1-array.h"
15 #include "connected.h"
16 #include "argv-array.h"
19 static const char receive_pack_usage
[] = "git receive-pack <git-dir>";
28 static int deny_deletes
;
29 static int deny_non_fast_forwards
;
30 static enum deny_action deny_current_branch
= DENY_UNCONFIGURED
;
31 static enum deny_action deny_delete_current
= DENY_UNCONFIGURED
;
32 static int receive_fsck_objects
= -1;
33 static int transfer_fsck_objects
= -1;
34 static int receive_unpack_limit
= -1;
35 static int transfer_unpack_limit
= -1;
36 static int unpack_limit
= 100;
37 static int report_status
;
38 static int use_sideband
;
40 static int prefer_ofs_delta
= 1;
41 static int auto_update_server_info
;
42 static int auto_gc
= 1;
43 static int fix_thin
= 1;
44 static const char *head_name
;
45 static void *head_name_to_free
;
46 static int sent_capabilities
;
47 static int shallow_update
;
48 static const char *alt_shallow_file
;
50 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
53 if (!strcasecmp(value
, "ignore"))
55 if (!strcasecmp(value
, "warn"))
57 if (!strcasecmp(value
, "refuse"))
60 if (git_config_bool(var
, value
))
65 static int receive_pack_config(const char *var
, const char *value
, void *cb
)
67 int status
= parse_hide_refs_config(var
, value
, "receive");
72 if (strcmp(var
, "receive.denydeletes") == 0) {
73 deny_deletes
= git_config_bool(var
, value
);
77 if (strcmp(var
, "receive.denynonfastforwards") == 0) {
78 deny_non_fast_forwards
= git_config_bool(var
, value
);
82 if (strcmp(var
, "receive.unpacklimit") == 0) {
83 receive_unpack_limit
= git_config_int(var
, value
);
87 if (strcmp(var
, "transfer.unpacklimit") == 0) {
88 transfer_unpack_limit
= git_config_int(var
, value
);
92 if (strcmp(var
, "receive.fsckobjects") == 0) {
93 receive_fsck_objects
= git_config_bool(var
, value
);
97 if (strcmp(var
, "transfer.fsckobjects") == 0) {
98 transfer_fsck_objects
= git_config_bool(var
, value
);
102 if (!strcmp(var
, "receive.denycurrentbranch")) {
103 deny_current_branch
= parse_deny_action(var
, value
);
107 if (strcmp(var
, "receive.denydeletecurrent") == 0) {
108 deny_delete_current
= parse_deny_action(var
, value
);
112 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
113 prefer_ofs_delta
= git_config_bool(var
, value
);
117 if (strcmp(var
, "receive.updateserverinfo") == 0) {
118 auto_update_server_info
= git_config_bool(var
, value
);
122 if (strcmp(var
, "receive.autogc") == 0) {
123 auto_gc
= git_config_bool(var
, value
);
127 if (strcmp(var
, "receive.shallowupdate") == 0) {
128 shallow_update
= git_config_bool(var
, value
);
132 return git_default_config(var
, value
, cb
);
135 static void show_ref(const char *path
, const unsigned char *sha1
)
137 if (ref_is_hidden(path
))
140 if (sent_capabilities
)
141 packet_write(1, "%s %s\n", sha1_to_hex(sha1
), path
);
143 packet_write(1, "%s %s%c%s%s agent=%s\n",
144 sha1_to_hex(sha1
), path
, 0,
145 " report-status delete-refs side-band-64k quiet",
146 prefer_ofs_delta
? " ofs-delta" : "",
147 git_user_agent_sanitized());
148 sent_capabilities
= 1;
151 static int show_ref_cb(const char *path
, const unsigned char *sha1
, int flag
, void *unused
)
153 path
= strip_namespace(path
);
155 * Advertise refs outside our current namespace as ".have"
156 * refs, so that the client can use them to minimize data
157 * transfer but will otherwise ignore them. This happens to
158 * cover ".have" that are thrown in by add_one_alternate_ref()
159 * to mark histories that are complete in our alternates as
164 show_ref(path
, sha1
);
168 static void show_one_alternate_sha1(const unsigned char sha1
[20], void *unused
)
170 show_ref(".have", sha1
);
173 static void collect_one_alternate_ref(const struct ref
*ref
, void *data
)
175 struct sha1_array
*sa
= data
;
176 sha1_array_append(sa
, ref
->old_sha1
);
179 static void write_head_info(void)
181 struct sha1_array sa
= SHA1_ARRAY_INIT
;
182 for_each_alternate_ref(collect_one_alternate_ref
, &sa
);
183 sha1_array_for_each_unique(&sa
, show_one_alternate_sha1
, NULL
);
184 sha1_array_clear(&sa
);
185 for_each_ref(show_ref_cb
, NULL
);
186 if (!sent_capabilities
)
187 show_ref("capabilities^{}", null_sha1
);
189 advertise_shallow_grafts(1);
196 struct command
*next
;
197 const char *error_string
;
198 unsigned int skip_update
:1,
201 unsigned char old_sha1
[20];
202 unsigned char new_sha1
[20];
203 char ref_name
[FLEX_ARRAY
]; /* more */
206 static void rp_error(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
207 static void rp_warning(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
209 static void report_message(const char *prefix
, const char *err
, va_list params
)
211 int sz
= strlen(prefix
);
214 strncpy(msg
, prefix
, sz
);
215 sz
+= vsnprintf(msg
+ sz
, sizeof(msg
) - sz
, err
, params
);
216 if (sz
> (sizeof(msg
) - 1))
217 sz
= sizeof(msg
) - 1;
221 send_sideband(1, 2, msg
, sz
, use_sideband
);
226 static void rp_warning(const char *err
, ...)
229 va_start(params
, err
);
230 report_message("warning: ", err
, params
);
234 static void rp_error(const char *err
, ...)
237 va_start(params
, err
);
238 report_message("error: ", err
, params
);
242 static int copy_to_sideband(int in
, int out
, void *arg
)
246 ssize_t sz
= xread(in
, data
, sizeof(data
));
249 send_sideband(1, 2, data
, sz
, use_sideband
);
255 typedef int (*feed_fn
)(void *, const char **, size_t *);
256 static int run_and_feed_hook(const char *hook_name
, feed_fn feed
, void *feed_state
)
258 struct child_process proc
= CHILD_PROCESS_INIT
;
263 argv
[0] = find_hook(hook_name
);
271 proc
.stdout_to_stderr
= 1;
274 memset(&muxer
, 0, sizeof(muxer
));
275 muxer
.proc
= copy_to_sideband
;
277 code
= start_async(&muxer
);
283 code
= start_command(&proc
);
286 finish_async(&muxer
);
293 if (feed(feed_state
, &buf
, &n
))
295 if (write_in_full(proc
.in
, buf
, n
) != n
)
300 finish_async(&muxer
);
301 return finish_command(&proc
);
304 struct receive_hook_feed_state
{
310 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
312 struct receive_hook_feed_state
*state
= state_
;
313 struct command
*cmd
= state
->cmd
;
316 state
->skip_broken
&& (cmd
->error_string
|| cmd
->did_not_exist
))
320 strbuf_reset(&state
->buf
);
321 strbuf_addf(&state
->buf
, "%s %s %s\n",
322 sha1_to_hex(cmd
->old_sha1
), sha1_to_hex(cmd
->new_sha1
),
324 state
->cmd
= cmd
->next
;
326 *bufp
= state
->buf
.buf
;
327 *sizep
= state
->buf
.len
;
332 static int run_receive_hook(struct command
*commands
, const char *hook_name
,
335 struct receive_hook_feed_state state
;
338 strbuf_init(&state
.buf
, 0);
339 state
.cmd
= commands
;
340 state
.skip_broken
= skip_broken
;
341 if (feed_receive_hook(&state
, NULL
, NULL
))
343 state
.cmd
= commands
;
344 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
345 strbuf_release(&state
.buf
);
349 static int run_update_hook(struct command
*cmd
)
352 struct child_process proc
= CHILD_PROCESS_INIT
;
355 argv
[0] = find_hook("update");
359 argv
[1] = cmd
->ref_name
;
360 argv
[2] = sha1_to_hex(cmd
->old_sha1
);
361 argv
[3] = sha1_to_hex(cmd
->new_sha1
);
365 proc
.stdout_to_stderr
= 1;
366 proc
.err
= use_sideband
? -1 : 0;
369 code
= start_command(&proc
);
373 copy_to_sideband(proc
.err
, -1, NULL
);
374 return finish_command(&proc
);
377 static int is_ref_checked_out(const char *ref
)
379 if (is_bare_repository())
384 return !strcmp(head_name
, ref
);
387 static char *refuse_unconfigured_deny_msg
[] = {
388 "By default, updating the current branch in a non-bare repository",
389 "is denied, because it will make the index and work tree inconsistent",
390 "with what you pushed, and will require 'git reset --hard' to match",
391 "the work tree to HEAD.",
393 "You can set 'receive.denyCurrentBranch' configuration variable to",
394 "'ignore' or 'warn' in the remote repository to allow pushing into",
395 "its current branch; however, this is not recommended unless you",
396 "arranged to update its work tree to match what you pushed in some",
399 "To squelch this message and still keep the default behaviour, set",
400 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
403 static void refuse_unconfigured_deny(void)
406 for (i
= 0; i
< ARRAY_SIZE(refuse_unconfigured_deny_msg
); i
++)
407 rp_error("%s", refuse_unconfigured_deny_msg
[i
]);
410 static char *refuse_unconfigured_deny_delete_current_msg
[] = {
411 "By default, deleting the current branch is denied, because the next",
412 "'git clone' won't result in any file checked out, causing confusion.",
414 "You can set 'receive.denyDeleteCurrent' configuration variable to",
415 "'warn' or 'ignore' in the remote repository to allow deleting the",
416 "current branch, with or without a warning message.",
418 "To squelch this message, you can set it to 'refuse'."
421 static void refuse_unconfigured_deny_delete_current(void)
425 i
< ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg
);
427 rp_error("%s", refuse_unconfigured_deny_delete_current_msg
[i
]);
430 static int command_singleton_iterator(void *cb_data
, unsigned char sha1
[20]);
431 static int update_shallow_ref(struct command
*cmd
, struct shallow_info
*si
)
433 static struct lock_file shallow_lock
;
434 struct sha1_array extra
= SHA1_ARRAY_INIT
;
435 const char *alt_file
;
436 uint32_t mask
= 1 << (cmd
->index
% 32);
439 trace_printf_key(&trace_shallow
,
440 "shallow: update_shallow_ref %s\n", cmd
->ref_name
);
441 for (i
= 0; i
< si
->shallow
->nr
; i
++)
442 if (si
->used_shallow
[i
] &&
443 (si
->used_shallow
[i
][cmd
->index
/ 32] & mask
) &&
444 !delayed_reachability_test(si
, i
))
445 sha1_array_append(&extra
, si
->shallow
->sha1
[i
]);
447 setup_alternate_shallow(&shallow_lock
, &alt_file
, &extra
);
448 if (check_shallow_connected(command_singleton_iterator
,
450 rollback_lock_file(&shallow_lock
);
451 sha1_array_clear(&extra
);
455 commit_lock_file(&shallow_lock
);
458 * Make sure setup_alternate_shallow() for the next ref does
459 * not lose these new roots..
461 for (i
= 0; i
< extra
.nr
; i
++)
462 register_shallow(extra
.sha1
[i
]);
464 si
->shallow_ref
[cmd
->index
] = 0;
465 sha1_array_clear(&extra
);
469 static const char *update(struct command
*cmd
, struct shallow_info
*si
)
471 const char *name
= cmd
->ref_name
;
472 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
473 const char *namespaced_name
;
474 unsigned char *old_sha1
= cmd
->old_sha1
;
475 unsigned char *new_sha1
= cmd
->new_sha1
;
476 struct ref_lock
*lock
;
478 /* only refs/... are allowed */
479 if (!starts_with(name
, "refs/") || check_refname_format(name
+ 5, 0)) {
480 rp_error("refusing to create funny ref '%s' remotely", name
);
481 return "funny refname";
484 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
485 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
487 if (is_ref_checked_out(namespaced_name
)) {
488 switch (deny_current_branch
) {
492 rp_warning("updating the current branch");
495 case DENY_UNCONFIGURED
:
496 rp_error("refusing to update checked out branch: %s", name
);
497 if (deny_current_branch
== DENY_UNCONFIGURED
)
498 refuse_unconfigured_deny();
499 return "branch is currently checked out";
503 if (!is_null_sha1(new_sha1
) && !has_sha1_file(new_sha1
)) {
504 error("unpack should have generated %s, "
505 "but I can't find it!", sha1_to_hex(new_sha1
));
509 if (!is_null_sha1(old_sha1
) && is_null_sha1(new_sha1
)) {
510 if (deny_deletes
&& starts_with(name
, "refs/heads/")) {
511 rp_error("denying ref deletion for %s", name
);
512 return "deletion prohibited";
515 if (!strcmp(namespaced_name
, head_name
)) {
516 switch (deny_delete_current
) {
520 rp_warning("deleting the current branch");
523 case DENY_UNCONFIGURED
:
524 if (deny_delete_current
== DENY_UNCONFIGURED
)
525 refuse_unconfigured_deny_delete_current();
526 rp_error("refusing to delete the current branch: %s", name
);
527 return "deletion of the current branch prohibited";
532 if (deny_non_fast_forwards
&& !is_null_sha1(new_sha1
) &&
533 !is_null_sha1(old_sha1
) &&
534 starts_with(name
, "refs/heads/")) {
535 struct object
*old_object
, *new_object
;
536 struct commit
*old_commit
, *new_commit
;
538 old_object
= parse_object(old_sha1
);
539 new_object
= parse_object(new_sha1
);
541 if (!old_object
|| !new_object
||
542 old_object
->type
!= OBJ_COMMIT
||
543 new_object
->type
!= OBJ_COMMIT
) {
544 error("bad sha1 objects for %s", name
);
547 old_commit
= (struct commit
*)old_object
;
548 new_commit
= (struct commit
*)new_object
;
549 if (!in_merge_bases(old_commit
, new_commit
)) {
550 rp_error("denying non-fast-forward %s"
551 " (you should pull first)", name
);
552 return "non-fast-forward";
555 if (run_update_hook(cmd
)) {
556 rp_error("hook declined to update %s", name
);
557 return "hook declined";
560 if (is_null_sha1(new_sha1
)) {
561 if (!parse_object(old_sha1
)) {
563 if (ref_exists(name
)) {
564 rp_warning("Allowing deletion of corrupt ref.");
566 rp_warning("Deleting a non-existent ref.");
567 cmd
->did_not_exist
= 1;
570 if (delete_ref(namespaced_name
, old_sha1
, 0)) {
571 rp_error("failed to delete %s", name
);
572 return "failed to delete";
574 return NULL
; /* good */
577 if (shallow_update
&& si
->shallow_ref
[cmd
->index
] &&
578 update_shallow_ref(cmd
, si
))
579 return "shallow error";
581 lock
= lock_any_ref_for_update(namespaced_name
, old_sha1
,
584 rp_error("failed to lock %s", name
);
585 return "failed to lock";
587 if (write_ref_sha1(lock
, new_sha1
, "push")) {
588 return "failed to write"; /* error() already called */
590 return NULL
; /* good */
594 static void run_update_post_hook(struct command
*commands
)
599 struct child_process proc
= CHILD_PROCESS_INIT
;
602 hook
= find_hook("post-update");
603 for (argc
= 0, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
604 if (cmd
->error_string
|| cmd
->did_not_exist
)
611 argv
= xmalloc(sizeof(*argv
) * (2 + argc
));
614 for (argc
= 1, cmd
= commands
; cmd
; cmd
= cmd
->next
) {
615 if (cmd
->error_string
|| cmd
->did_not_exist
)
617 argv
[argc
] = xstrdup(cmd
->ref_name
);
623 proc
.stdout_to_stderr
= 1;
624 proc
.err
= use_sideband
? -1 : 0;
627 if (!start_command(&proc
)) {
629 copy_to_sideband(proc
.err
, -1, NULL
);
630 finish_command(&proc
);
634 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
636 struct strbuf buf
= STRBUF_INIT
;
637 const char *dst_name
;
638 struct string_list_item
*item
;
639 struct command
*dst_cmd
;
640 unsigned char sha1
[20];
641 char cmd_oldh
[41], cmd_newh
[41], dst_oldh
[41], dst_newh
[41];
644 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
645 dst_name
= resolve_ref_unsafe(buf
.buf
, sha1
, 0, &flag
);
646 strbuf_release(&buf
);
648 if (!(flag
& REF_ISSYMREF
))
651 dst_name
= strip_namespace(dst_name
);
653 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
654 cmd
->skip_update
= 1;
655 cmd
->error_string
= "broken symref";
659 if ((item
= string_list_lookup(list
, dst_name
)) == NULL
)
662 cmd
->skip_update
= 1;
664 dst_cmd
= (struct command
*) item
->util
;
666 if (!hashcmp(cmd
->old_sha1
, dst_cmd
->old_sha1
) &&
667 !hashcmp(cmd
->new_sha1
, dst_cmd
->new_sha1
))
670 dst_cmd
->skip_update
= 1;
672 strcpy(cmd_oldh
, find_unique_abbrev(cmd
->old_sha1
, DEFAULT_ABBREV
));
673 strcpy(cmd_newh
, find_unique_abbrev(cmd
->new_sha1
, DEFAULT_ABBREV
));
674 strcpy(dst_oldh
, find_unique_abbrev(dst_cmd
->old_sha1
, DEFAULT_ABBREV
));
675 strcpy(dst_newh
, find_unique_abbrev(dst_cmd
->new_sha1
, DEFAULT_ABBREV
));
676 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
677 " its target '%s' (%s..%s)",
678 cmd
->ref_name
, cmd_oldh
, cmd_newh
,
679 dst_cmd
->ref_name
, dst_oldh
, dst_newh
);
681 cmd
->error_string
= dst_cmd
->error_string
=
682 "inconsistent aliased update";
685 static void check_aliased_updates(struct command
*commands
)
688 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
690 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
691 struct string_list_item
*item
=
692 string_list_append(&ref_list
, cmd
->ref_name
);
693 item
->util
= (void *)cmd
;
695 sort_string_list(&ref_list
);
697 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
698 if (!cmd
->error_string
)
699 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
,
718 struct shallow_info
*si
)
722 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
723 struct command
*singleton
= cmd
;
724 if (shallow_update
&& si
->shallow_ref
[cmd
->index
])
725 /* to be checked in update_shallow_ref() */
727 if (!check_everything_connected(command_singleton_iterator
,
730 cmd
->error_string
= "missing necessary objects";
734 struct iterate_data
{
735 struct command
*cmds
;
736 struct shallow_info
*si
;
739 static int iterate_receive_command_list(void *cb_data
, unsigned char sha1
[20])
741 struct iterate_data
*data
= cb_data
;
742 struct command
**cmd_list
= &data
->cmds
;
743 struct command
*cmd
= *cmd_list
;
745 for (; cmd
; cmd
= cmd
->next
) {
746 if (shallow_update
&& data
->si
->shallow_ref
[cmd
->index
])
747 /* to be checked in update_shallow_ref() */
749 if (!is_null_sha1(cmd
->new_sha1
) && !cmd
->skip_update
) {
750 hashcpy(sha1
, cmd
->new_sha1
);
751 *cmd_list
= cmd
->next
;
756 return -1; /* end of list */
759 static void reject_updates_to_hidden(struct command
*commands
)
763 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
764 if (cmd
->error_string
|| !ref_is_hidden(cmd
->ref_name
))
766 if (is_null_sha1(cmd
->new_sha1
))
767 cmd
->error_string
= "deny deleting a hidden ref";
769 cmd
->error_string
= "deny updating a hidden ref";
773 static void execute_commands(struct command
*commands
,
774 const char *unpacker_error
,
775 struct shallow_info
*si
)
777 int checked_connectivity
;
779 unsigned char sha1
[20];
780 struct iterate_data data
;
782 if (unpacker_error
) {
783 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
784 cmd
->error_string
= "unpacker error";
788 data
.cmds
= commands
;
790 if (check_everything_connected(iterate_receive_command_list
, 0, &data
))
791 set_connectivity_errors(commands
, si
);
793 reject_updates_to_hidden(commands
);
795 if (run_receive_hook(commands
, "pre-receive", 0)) {
796 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
797 if (!cmd
->error_string
)
798 cmd
->error_string
= "pre-receive hook declined";
803 check_aliased_updates(commands
);
805 free(head_name_to_free
);
806 head_name
= head_name_to_free
= resolve_refdup("HEAD", sha1
, 0, NULL
);
808 checked_connectivity
= 1;
809 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
810 if (cmd
->error_string
)
813 if (cmd
->skip_update
)
816 cmd
->error_string
= update(cmd
, si
);
817 if (shallow_update
&& !cmd
->error_string
&&
818 si
->shallow_ref
[cmd
->index
]) {
819 error("BUG: connectivity check has not been run on ref %s",
821 checked_connectivity
= 0;
825 if (shallow_update
&& !checked_connectivity
)
826 error("BUG: run 'git fsck' for safety.\n"
827 "If there are errors, try to remove "
828 "the reported refs above");
831 static struct command
*read_head_info(struct sha1_array
*shallow
)
833 struct command
*commands
= NULL
;
834 struct command
**p
= &commands
;
837 unsigned char old_sha1
[20], new_sha1
[20];
842 line
= packet_read_line(0, &len
);
846 if (len
== 48 && starts_with(line
, "shallow ")) {
847 if (get_sha1_hex(line
+ 8, old_sha1
))
848 die("protocol error: expected shallow sha, got '%s'", line
+ 8);
849 sha1_array_append(shallow
, old_sha1
);
856 get_sha1_hex(line
, old_sha1
) ||
857 get_sha1_hex(line
+ 41, new_sha1
))
858 die("protocol error: expected old/new/ref, got '%s'",
862 reflen
= strlen(refname
);
863 if (reflen
+ 82 < len
) {
864 const char *feature_list
= refname
+ reflen
+ 1;
865 if (parse_feature_request(feature_list
, "report-status"))
867 if (parse_feature_request(feature_list
, "side-band-64k"))
868 use_sideband
= LARGE_PACKET_MAX
;
869 if (parse_feature_request(feature_list
, "quiet"))
872 cmd
= xcalloc(1, sizeof(struct command
) + len
- 80);
873 hashcpy(cmd
->old_sha1
, old_sha1
);
874 hashcpy(cmd
->new_sha1
, new_sha1
);
875 memcpy(cmd
->ref_name
, line
+ 82, len
- 81);
882 static const char *parse_pack_header(struct pack_header
*hdr
)
884 switch (read_pack_header(0, hdr
)) {
886 return "eof before pack header was fully read";
888 case PH_ERROR_PACK_SIGNATURE
:
889 return "protocol error (pack signature mismatch detected)";
891 case PH_ERROR_PROTOCOL
:
892 return "protocol error (pack version unsupported)";
895 return "unknown error in parse_pack_header";
902 static const char *pack_lockfile
;
904 static const char *unpack(int err_fd
, struct shallow_info
*si
)
906 struct pack_header hdr
;
907 struct argv_array av
= ARGV_ARRAY_INIT
;
911 struct child_process child
= CHILD_PROCESS_INIT
;
912 int fsck_objects
= (receive_fsck_objects
>= 0
913 ? receive_fsck_objects
914 : transfer_fsck_objects
>= 0
915 ? transfer_fsck_objects
918 hdr_err
= parse_pack_header(&hdr
);
924 snprintf(hdr_arg
, sizeof(hdr_arg
),
925 "--pack_header=%"PRIu32
",%"PRIu32
,
926 ntohl(hdr
.hdr_version
), ntohl(hdr
.hdr_entries
));
928 if (si
->nr_ours
|| si
->nr_theirs
) {
929 alt_shallow_file
= setup_temporary_shallow(si
->shallow
);
930 argv_array_pushl(&av
, "--shallow-file", alt_shallow_file
, NULL
);
933 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
934 argv_array_pushl(&av
, "unpack-objects", hdr_arg
, NULL
);
936 argv_array_push(&av
, "-q");
938 argv_array_push(&av
, "--strict");
939 child
.argv
= av
.argv
;
943 status
= run_command(&child
);
945 return "unpack-objects abnormal exit";
950 s
= sprintf(keep_arg
, "--keep=receive-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
951 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
952 strcpy(keep_arg
+ s
, "localhost");
954 argv_array_pushl(&av
, "index-pack",
955 "--stdin", hdr_arg
, keep_arg
, NULL
);
957 argv_array_push(&av
, "--strict");
959 argv_array_push(&av
, "--fix-thin");
960 child
.argv
= av
.argv
;
964 status
= start_command(&child
);
966 return "index-pack fork failed";
967 pack_lockfile
= index_pack_lockfile(child
.out
);
969 status
= finish_command(&child
);
971 return "index-pack abnormal exit";
972 reprepare_packed_git();
977 static const char *unpack_with_sideband(struct shallow_info
*si
)
983 return unpack(0, si
);
985 memset(&muxer
, 0, sizeof(muxer
));
986 muxer
.proc
= copy_to_sideband
;
988 if (start_async(&muxer
))
991 ret
= unpack(muxer
.in
, si
);
993 finish_async(&muxer
);
997 static void prepare_shallow_update(struct command
*commands
,
998 struct shallow_info
*si
)
1000 int i
, j
, k
, bitmap_size
= (si
->ref
->nr
+ 31) / 32;
1002 si
->used_shallow
= xmalloc(sizeof(*si
->used_shallow
) *
1004 assign_shallow_commits_to_refs(si
, si
->used_shallow
, NULL
);
1006 si
->need_reachability_test
=
1007 xcalloc(si
->shallow
->nr
, sizeof(*si
->need_reachability_test
));
1009 xcalloc(si
->shallow
->nr
, sizeof(*si
->reachable
));
1010 si
->shallow_ref
= xcalloc(si
->ref
->nr
, sizeof(*si
->shallow_ref
));
1012 for (i
= 0; i
< si
->nr_ours
; i
++)
1013 si
->need_reachability_test
[si
->ours
[i
]] = 1;
1015 for (i
= 0; i
< si
->shallow
->nr
; i
++) {
1016 if (!si
->used_shallow
[i
])
1018 for (j
= 0; j
< bitmap_size
; j
++) {
1019 if (!si
->used_shallow
[i
][j
])
1021 si
->need_reachability_test
[i
]++;
1022 for (k
= 0; k
< 32; k
++)
1023 if (si
->used_shallow
[i
][j
] & (1 << k
))
1024 si
->shallow_ref
[j
* 32 + k
]++;
1028 * true for those associated with some refs and belong
1029 * in "ours" list aka "step 7 not done yet"
1031 si
->need_reachability_test
[i
] =
1032 si
->need_reachability_test
[i
] > 1;
1036 * keep hooks happy by forcing a temporary shallow file via
1037 * env variable because we can't add --shallow-file to every
1038 * command. check_everything_connected() will be done with
1039 * true .git/shallow though.
1041 setenv(GIT_SHALLOW_FILE_ENVIRONMENT
, alt_shallow_file
, 1);
1044 static void update_shallow_info(struct command
*commands
,
1045 struct shallow_info
*si
,
1046 struct sha1_array
*ref
)
1048 struct command
*cmd
;
1050 remove_nonexistent_theirs_shallow(si
);
1051 if (!si
->nr_ours
&& !si
->nr_theirs
) {
1056 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1057 if (is_null_sha1(cmd
->new_sha1
))
1059 sha1_array_append(ref
, cmd
->new_sha1
);
1060 cmd
->index
= ref
->nr
- 1;
1064 if (shallow_update
) {
1065 prepare_shallow_update(commands
, si
);
1069 ref_status
= xmalloc(sizeof(*ref_status
) * ref
->nr
);
1070 assign_shallow_commits_to_refs(si
, NULL
, ref_status
);
1071 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1072 if (is_null_sha1(cmd
->new_sha1
))
1074 if (ref_status
[cmd
->index
]) {
1075 cmd
->error_string
= "shallow update not allowed";
1076 cmd
->skip_update
= 1;
1082 static void report(struct command
*commands
, const char *unpack_status
)
1084 struct command
*cmd
;
1085 struct strbuf buf
= STRBUF_INIT
;
1087 packet_buf_write(&buf
, "unpack %s\n",
1088 unpack_status
? unpack_status
: "ok");
1089 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1090 if (!cmd
->error_string
)
1091 packet_buf_write(&buf
, "ok %s\n",
1094 packet_buf_write(&buf
, "ng %s %s\n",
1095 cmd
->ref_name
, cmd
->error_string
);
1097 packet_buf_flush(&buf
);
1100 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
1102 write_or_die(1, buf
.buf
, buf
.len
);
1103 strbuf_release(&buf
);
1106 static int delete_only(struct command
*commands
)
1108 struct command
*cmd
;
1109 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1110 if (!is_null_sha1(cmd
->new_sha1
))
1116 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
1118 int advertise_refs
= 0;
1119 int stateless_rpc
= 0;
1121 const char *dir
= NULL
;
1122 struct command
*commands
;
1123 struct sha1_array shallow
= SHA1_ARRAY_INIT
;
1124 struct sha1_array ref
= SHA1_ARRAY_INIT
;
1125 struct shallow_info si
;
1127 packet_trace_identity("receive-pack");
1130 for (i
= 1; i
< argc
; i
++) {
1131 const char *arg
= *argv
++;
1134 if (!strcmp(arg
, "--quiet")) {
1139 if (!strcmp(arg
, "--advertise-refs")) {
1143 if (!strcmp(arg
, "--stateless-rpc")) {
1147 if (!strcmp(arg
, "--reject-thin-pack-for-testing")) {
1152 usage(receive_pack_usage
);
1155 usage(receive_pack_usage
);
1159 usage(receive_pack_usage
);
1163 if (!enter_repo(dir
, 0))
1164 die("'%s' does not appear to be a git repository", dir
);
1166 git_config(receive_pack_config
, NULL
);
1168 if (0 <= transfer_unpack_limit
)
1169 unpack_limit
= transfer_unpack_limit
;
1170 else if (0 <= receive_unpack_limit
)
1171 unpack_limit
= receive_unpack_limit
;
1173 if (advertise_refs
|| !stateless_rpc
) {
1179 if ((commands
= read_head_info(&shallow
)) != NULL
) {
1180 const char *unpack_status
= NULL
;
1182 prepare_shallow_info(&si
, &shallow
);
1183 if (!si
.nr_ours
&& !si
.nr_theirs
)
1185 if (!delete_only(commands
)) {
1186 unpack_status
= unpack_with_sideband(&si
);
1187 update_shallow_info(commands
, &si
, &ref
);
1189 execute_commands(commands
, unpack_status
, &si
);
1191 unlink_or_warn(pack_lockfile
);
1193 report(commands
, unpack_status
);
1194 run_receive_hook(commands
, "post-receive", 1);
1195 run_update_post_hook(commands
);
1197 const char *argv_gc_auto
[] = {
1198 "gc", "--auto", "--quiet", NULL
,
1200 int opt
= RUN_GIT_CMD
| RUN_COMMAND_STDOUT_TO_STDERR
;
1201 run_command_v_opt(argv_gc_auto
, opt
);
1203 if (auto_update_server_info
)
1204 update_server_info(0);
1205 clear_shallow_info(&si
);
1209 sha1_array_clear(&shallow
);
1210 sha1_array_clear(&ref
);