3 #include "repository.h"
5 #include "environment.h"
13 #include "run-command.h"
20 #include "string-list.h"
21 #include "oid-array.h"
22 #include "connected.h"
26 #include "gpg-interface.h"
29 #include "tmp-objdir.h"
32 #include "object-name.h"
33 #include "object-store-ll.h"
36 #include "commit-reach.h"
37 #include "server-info.h"
42 #include "parse-options.h"
44 static const char * const receive_pack_usage
[] = {
45 N_("git receive-pack <git-dir>"),
57 static int deny_deletes
;
58 static int deny_non_fast_forwards
;
59 static enum deny_action deny_current_branch
= DENY_UNCONFIGURED
;
60 static enum deny_action deny_delete_current
= DENY_UNCONFIGURED
;
61 static int receive_fsck_objects
= -1;
62 static int transfer_fsck_objects
= -1;
63 static struct strbuf fsck_msg_types
= STRBUF_INIT
;
64 static int receive_unpack_limit
= -1;
65 static int transfer_unpack_limit
= -1;
66 static int advertise_atomic_push
= 1;
67 static int advertise_push_options
;
68 static int advertise_sid
;
69 static int unpack_limit
= 100;
70 static off_t max_input_size
;
71 static int report_status
;
72 static int report_status_v2
;
73 static int use_sideband
;
74 static int use_atomic
;
75 static int use_push_options
;
77 static int prefer_ofs_delta
= 1;
78 static int auto_update_server_info
;
79 static int auto_gc
= 1;
80 static int reject_thin
;
81 static int stateless_rpc
;
82 static const char *service_dir
;
83 static const char *head_name
;
84 static void *head_name_to_free
;
85 static int sent_capabilities
;
86 static int shallow_update
;
87 static const char *alt_shallow_file
;
88 static struct strbuf push_cert
= STRBUF_INIT
;
89 static struct object_id push_cert_oid
;
90 static struct signature_check sigcheck
;
91 static const char *push_cert_nonce
;
92 static const char *cert_nonce_seed
;
93 static struct strvec hidden_refs
= STRVEC_INIT
;
95 static const char *NONCE_UNSOLICITED
= "UNSOLICITED";
96 static const char *NONCE_BAD
= "BAD";
97 static const char *NONCE_MISSING
= "MISSING";
98 static const char *NONCE_OK
= "OK";
99 static const char *NONCE_SLOP
= "SLOP";
100 static const char *nonce_status
;
101 static long nonce_stamp_slop
;
102 static timestamp_t nonce_stamp_slop_limit
;
103 static struct ref_transaction
*transaction
;
110 static int keepalive_in_sec
= 5;
112 static struct tmp_objdir
*tmp_objdir
;
114 static struct proc_receive_ref
{
115 unsigned int want_add
:1,
120 struct proc_receive_ref
*next
;
123 static void proc_receive_ref_append(const char *prefix
);
125 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
128 if (!strcasecmp(value
, "ignore"))
130 if (!strcasecmp(value
, "warn"))
132 if (!strcasecmp(value
, "refuse"))
134 if (!strcasecmp(value
, "updateinstead"))
135 return DENY_UPDATE_INSTEAD
;
137 if (git_config_bool(var
, value
))
142 static int receive_pack_config(const char *var
, const char *value
,
143 const struct config_context
*ctx
, void *cb
)
146 int status
= parse_hide_refs_config(var
, value
, "receive", &hidden_refs
);
151 if (strcmp(var
, "receive.denydeletes") == 0) {
152 deny_deletes
= git_config_bool(var
, value
);
156 if (strcmp(var
, "receive.denynonfastforwards") == 0) {
157 deny_non_fast_forwards
= git_config_bool(var
, value
);
161 if (strcmp(var
, "receive.unpacklimit") == 0) {
162 receive_unpack_limit
= git_config_int(var
, value
, ctx
->kvi
);
166 if (strcmp(var
, "transfer.unpacklimit") == 0) {
167 transfer_unpack_limit
= git_config_int(var
, value
, ctx
->kvi
);
171 if (strcmp(var
, "receive.fsck.skiplist") == 0) {
174 if (git_config_pathname(&path
, var
, value
))
176 strbuf_addf(&fsck_msg_types
, "%cskiplist=%s",
177 fsck_msg_types
.len
? ',' : '=', path
);
182 if (skip_prefix(var
, "receive.fsck.", &msg_id
)) {
184 return config_error_nonbool(var
);
185 if (is_valid_msg_type(msg_id
, value
))
186 strbuf_addf(&fsck_msg_types
, "%c%s=%s",
187 fsck_msg_types
.len
? ',' : '=', msg_id
, value
);
189 warning("skipping unknown msg id '%s'", msg_id
);
193 if (strcmp(var
, "receive.fsckobjects") == 0) {
194 receive_fsck_objects
= git_config_bool(var
, value
);
198 if (strcmp(var
, "transfer.fsckobjects") == 0) {
199 transfer_fsck_objects
= git_config_bool(var
, value
);
203 if (!strcmp(var
, "receive.denycurrentbranch")) {
204 deny_current_branch
= parse_deny_action(var
, value
);
208 if (strcmp(var
, "receive.denydeletecurrent") == 0) {
209 deny_delete_current
= parse_deny_action(var
, value
);
213 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
214 prefer_ofs_delta
= git_config_bool(var
, value
);
218 if (strcmp(var
, "receive.updateserverinfo") == 0) {
219 auto_update_server_info
= git_config_bool(var
, value
);
223 if (strcmp(var
, "receive.autogc") == 0) {
224 auto_gc
= git_config_bool(var
, value
);
228 if (strcmp(var
, "receive.shallowupdate") == 0) {
229 shallow_update
= git_config_bool(var
, value
);
233 if (strcmp(var
, "receive.certnonceseed") == 0)
234 return git_config_string(&cert_nonce_seed
, var
, value
);
236 if (strcmp(var
, "receive.certnonceslop") == 0) {
237 nonce_stamp_slop_limit
= git_config_ulong(var
, value
, ctx
->kvi
);
241 if (strcmp(var
, "receive.advertiseatomic") == 0) {
242 advertise_atomic_push
= git_config_bool(var
, value
);
246 if (strcmp(var
, "receive.advertisepushoptions") == 0) {
247 advertise_push_options
= git_config_bool(var
, value
);
251 if (strcmp(var
, "receive.keepalive") == 0) {
252 keepalive_in_sec
= git_config_int(var
, value
, ctx
->kvi
);
256 if (strcmp(var
, "receive.maxinputsize") == 0) {
257 max_input_size
= git_config_int64(var
, value
, ctx
->kvi
);
261 if (strcmp(var
, "receive.procreceiverefs") == 0) {
263 return config_error_nonbool(var
);
264 proc_receive_ref_append(value
);
268 if (strcmp(var
, "transfer.advertisesid") == 0) {
269 advertise_sid
= git_config_bool(var
, value
);
273 return git_default_config(var
, value
, ctx
, cb
);
276 static void show_ref(const char *path
, const struct object_id
*oid
)
278 if (sent_capabilities
) {
279 packet_write_fmt(1, "%s %s\n", oid_to_hex(oid
), path
);
281 struct strbuf cap
= STRBUF_INIT
;
284 "report-status report-status-v2 delete-refs side-band-64k quiet");
285 if (advertise_atomic_push
)
286 strbuf_addstr(&cap
, " atomic");
287 if (prefer_ofs_delta
)
288 strbuf_addstr(&cap
, " ofs-delta");
290 strbuf_addf(&cap
, " push-cert=%s", push_cert_nonce
);
291 if (advertise_push_options
)
292 strbuf_addstr(&cap
, " push-options");
294 strbuf_addf(&cap
, " session-id=%s", trace2_session_id());
295 strbuf_addf(&cap
, " object-format=%s", the_hash_algo
->name
);
296 strbuf_addf(&cap
, " agent=%s", git_user_agent_sanitized());
297 packet_write_fmt(1, "%s %s%c%s\n",
298 oid_to_hex(oid
), path
, 0, cap
.buf
);
299 strbuf_release(&cap
);
300 sent_capabilities
= 1;
304 static int show_ref_cb(const char *path_full
, const struct object_id
*oid
,
305 int flag UNUSED
, void *data
)
307 struct oidset
*seen
= data
;
308 const char *path
= strip_namespace(path_full
);
310 if (ref_is_hidden(path
, path_full
, &hidden_refs
))
314 * Advertise refs outside our current namespace as ".have"
315 * refs, so that the client can use them to minimize data
316 * transfer but will otherwise ignore them.
319 if (oidset_insert(seen
, oid
))
323 oidset_insert(seen
, oid
);
329 static void show_one_alternate_ref(const struct object_id
*oid
,
332 struct oidset
*seen
= data
;
334 if (oidset_insert(seen
, oid
))
337 show_ref(".have", oid
);
340 static void write_head_info(void)
342 static struct oidset seen
= OIDSET_INIT
;
344 refs_for_each_fullref_in(get_main_ref_store(the_repository
), "",
345 hidden_refs_to_excludes(&hidden_refs
),
347 for_each_alternate_ref(show_one_alternate_ref
, &seen
);
349 if (!sent_capabilities
)
350 show_ref("capabilities^{}", null_oid());
352 advertise_shallow_grafts(1);
358 #define RUN_PROC_RECEIVE_SCHEDULED 1
359 #define RUN_PROC_RECEIVE_RETURNED 2
361 struct command
*next
;
362 const char *error_string
;
363 struct ref_push_report
*report
;
364 unsigned int skip_update
:1,
368 struct object_id old_oid
;
369 struct object_id new_oid
;
370 char ref_name
[FLEX_ARRAY
]; /* more */
373 static void proc_receive_ref_append(const char *prefix
)
375 struct proc_receive_ref
*ref_pattern
;
379 CALLOC_ARRAY(ref_pattern
, 1);
380 p
= strchr(prefix
, ':');
384 ref_pattern
->want_add
= 1;
385 else if (*prefix
== 'd')
386 ref_pattern
->want_delete
= 1;
387 else if (*prefix
== 'm')
388 ref_pattern
->want_modify
= 1;
389 else if (*prefix
== '!')
390 ref_pattern
->negative_ref
= 1;
395 ref_pattern
->want_add
= 1;
396 ref_pattern
->want_delete
= 1;
397 ref_pattern
->want_modify
= 1;
399 len
= strlen(prefix
);
400 while (len
&& prefix
[len
- 1] == '/')
402 ref_pattern
->ref_prefix
= xmemdupz(prefix
, len
);
403 if (!proc_receive_ref
) {
404 proc_receive_ref
= ref_pattern
;
406 struct proc_receive_ref
*end
;
408 end
= proc_receive_ref
;
411 end
->next
= ref_pattern
;
415 static int proc_receive_ref_matches(struct command
*cmd
)
417 struct proc_receive_ref
*p
;
419 if (!proc_receive_ref
)
422 for (p
= proc_receive_ref
; p
; p
= p
->next
) {
423 const char *match
= p
->ref_prefix
;
426 if (!p
->want_add
&& is_null_oid(&cmd
->old_oid
))
428 else if (!p
->want_delete
&& is_null_oid(&cmd
->new_oid
))
430 else if (!p
->want_modify
&&
431 !is_null_oid(&cmd
->old_oid
) &&
432 !is_null_oid(&cmd
->new_oid
))
435 if (skip_prefix(cmd
->ref_name
, match
, &remains
) &&
436 (!*remains
|| *remains
== '/')) {
437 if (!p
->negative_ref
)
439 } else if (p
->negative_ref
) {
446 static void report_message(const char *prefix
, const char *err
, va_list params
)
451 sz
= xsnprintf(msg
, sizeof(msg
), "%s", prefix
);
452 sz
+= vsnprintf(msg
+ sz
, sizeof(msg
) - sz
, err
, params
);
453 if (sz
> (sizeof(msg
) - 1))
454 sz
= sizeof(msg
) - 1;
458 send_sideband(1, 2, msg
, sz
, use_sideband
);
463 __attribute__((format (printf
, 1, 2)))
464 static void rp_warning(const char *err
, ...)
467 va_start(params
, err
);
468 report_message("warning: ", err
, params
);
472 __attribute__((format (printf
, 1, 2)))
473 static void rp_error(const char *err
, ...)
476 va_start(params
, err
);
477 report_message("error: ", err
, params
);
481 static int copy_to_sideband(int in
, int out UNUSED
, void *arg UNUSED
)
484 int keepalive_active
= 0;
486 if (keepalive_in_sec
<= 0)
487 use_keepalive
= KEEPALIVE_NEVER
;
488 if (use_keepalive
== KEEPALIVE_ALWAYS
)
489 keepalive_active
= 1;
494 if (keepalive_active
) {
500 ret
= poll(&pfd
, 1, 1000 * keepalive_in_sec
);
507 } else if (ret
== 0) {
508 /* no data; send a keepalive packet */
509 static const char buf
[] = "0005\1";
510 write_or_die(1, buf
, sizeof(buf
) - 1);
512 } /* else there is actual data to read */
515 sz
= xread(in
, data
, sizeof(data
));
519 if (use_keepalive
== KEEPALIVE_AFTER_NUL
&& !keepalive_active
) {
520 const char *p
= memchr(data
, '\0', sz
);
523 * The NUL tells us to start sending keepalives. Make
524 * sure we send any other data we read along
527 keepalive_active
= 1;
528 send_sideband(1, 2, data
, p
- data
, use_sideband
);
529 send_sideband(1, 2, p
+ 1, sz
- (p
- data
+ 1), use_sideband
);
535 * Either we're not looking for a NUL signal, or we didn't see
536 * it yet; just pass along the data.
538 send_sideband(1, 2, data
, sz
, use_sideband
);
544 static void hmac_hash(unsigned char *out
,
545 const char *key_in
, size_t key_len
,
546 const char *text
, size_t text_len
)
548 unsigned char key
[GIT_MAX_BLKSZ
];
549 unsigned char k_ipad
[GIT_MAX_BLKSZ
];
550 unsigned char k_opad
[GIT_MAX_BLKSZ
];
554 /* RFC 2104 2. (1) */
555 memset(key
, '\0', GIT_MAX_BLKSZ
);
556 if (the_hash_algo
->blksz
< key_len
) {
557 the_hash_algo
->init_fn(&ctx
);
558 the_hash_algo
->update_fn(&ctx
, key_in
, key_len
);
559 the_hash_algo
->final_fn(key
, &ctx
);
561 memcpy(key
, key_in
, key_len
);
564 /* RFC 2104 2. (2) & (5) */
565 for (i
= 0; i
< sizeof(key
); i
++) {
566 k_ipad
[i
] = key
[i
] ^ 0x36;
567 k_opad
[i
] = key
[i
] ^ 0x5c;
570 /* RFC 2104 2. (3) & (4) */
571 the_hash_algo
->init_fn(&ctx
);
572 the_hash_algo
->update_fn(&ctx
, k_ipad
, sizeof(k_ipad
));
573 the_hash_algo
->update_fn(&ctx
, text
, text_len
);
574 the_hash_algo
->final_fn(out
, &ctx
);
576 /* RFC 2104 2. (6) & (7) */
577 the_hash_algo
->init_fn(&ctx
);
578 the_hash_algo
->update_fn(&ctx
, k_opad
, sizeof(k_opad
));
579 the_hash_algo
->update_fn(&ctx
, out
, the_hash_algo
->rawsz
);
580 the_hash_algo
->final_fn(out
, &ctx
);
583 static char *prepare_push_cert_nonce(const char *path
, timestamp_t stamp
)
585 struct strbuf buf
= STRBUF_INIT
;
586 unsigned char hash
[GIT_MAX_RAWSZ
];
588 strbuf_addf(&buf
, "%s:%"PRItime
, path
, stamp
);
589 hmac_hash(hash
, buf
.buf
, buf
.len
, cert_nonce_seed
, strlen(cert_nonce_seed
));
590 strbuf_release(&buf
);
592 /* RFC 2104 5. HMAC-SHA1 or HMAC-SHA256 */
593 strbuf_addf(&buf
, "%"PRItime
"-%.*s", stamp
, (int)the_hash_algo
->hexsz
, hash_to_hex(hash
));
594 return strbuf_detach(&buf
, NULL
);
597 static char *find_header(const char *msg
, size_t len
, const char *key
,
598 const char **next_line
)
601 const char *val
= find_header_mem(msg
, len
, key
, &out_len
);
607 *next_line
= val
+ out_len
+ 1;
609 return xmemdupz(val
, out_len
);
613 * Return zero if a and b are equal up to n bytes and nonzero if they are not.
614 * This operation is guaranteed to run in constant time to avoid leaking data.
616 static int constant_memequal(const char *a
, const char *b
, size_t n
)
621 for (i
= 0; i
< n
; i
++)
626 static const char *check_nonce(const char *buf
, size_t len
)
628 char *nonce
= find_header(buf
, len
, "nonce", NULL
);
629 timestamp_t stamp
, ostamp
;
630 char *bohmac
, *expect
= NULL
;
631 const char *retval
= NONCE_BAD
;
635 retval
= NONCE_MISSING
;
637 } else if (!push_cert_nonce
) {
638 retval
= NONCE_UNSOLICITED
;
640 } else if (!strcmp(push_cert_nonce
, nonce
)) {
645 if (!stateless_rpc
) {
646 /* returned nonce MUST match what we gave out earlier */
652 * In stateless mode, we may be receiving a nonce issued by
653 * another instance of the server that serving the same
654 * repository, and the timestamps may not match, but the
655 * nonce-seed and dir should match, so we can recompute and
656 * report the time slop.
658 * In addition, when a nonce issued by another instance has
659 * timestamp within receive.certnonceslop seconds, we pretend
660 * as if we issued that nonce when reporting to the hook.
663 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
664 if (*nonce
<= '0' || '9' < *nonce
) {
668 stamp
= parse_timestamp(nonce
, &bohmac
, 10);
669 if (bohmac
== nonce
|| bohmac
[0] != '-') {
674 noncelen
= strlen(nonce
);
675 expect
= prepare_push_cert_nonce(service_dir
, stamp
);
676 if (noncelen
!= strlen(expect
)) {
677 /* This is not even the right size. */
681 if (constant_memequal(expect
, nonce
, noncelen
)) {
682 /* Not what we would have signed earlier */
688 * By how many seconds is this nonce stale? Negative value
689 * would mean it was issued by another server with its clock
690 * skewed in the future.
692 ostamp
= parse_timestamp(push_cert_nonce
, NULL
, 10);
693 nonce_stamp_slop
= (long)ostamp
- (long)stamp
;
695 if (nonce_stamp_slop_limit
&&
696 labs(nonce_stamp_slop
) <= nonce_stamp_slop_limit
) {
698 * Pretend as if the received nonce (which passes the
699 * HMAC check, so it is not a forged by third-party)
702 free((void *)push_cert_nonce
);
703 push_cert_nonce
= xstrdup(nonce
);
716 * Return 1 if there is no push_cert or if the push options in push_cert are
717 * the same as those in the argument; 0 otherwise.
719 static int check_cert_push_options(const struct string_list
*push_options
)
721 const char *buf
= push_cert
.buf
;
722 int len
= push_cert
.len
;
725 const char *next_line
;
726 int options_seen
= 0;
733 while ((option
= find_header(buf
, len
, "push-option", &next_line
))) {
734 len
-= (next_line
- buf
);
737 if (options_seen
> push_options
->nr
739 push_options
->items
[options_seen
- 1].string
)) {
746 if (options_seen
!= push_options
->nr
)
754 static void prepare_push_cert_sha1(struct child_process
*proc
)
756 static int already_done
;
762 int bogs
/* beginning_of_gpg_sig */;
765 if (write_object_file(push_cert
.buf
, push_cert
.len
, OBJ_BLOB
,
767 oidclr(&push_cert_oid
);
769 memset(&sigcheck
, '\0', sizeof(sigcheck
));
771 bogs
= parse_signed_buffer(push_cert
.buf
, push_cert
.len
);
772 sigcheck
.payload
= xmemdupz(push_cert
.buf
, bogs
);
773 sigcheck
.payload_len
= bogs
;
774 check_signature(&sigcheck
, push_cert
.buf
+ bogs
,
775 push_cert
.len
- bogs
);
777 nonce_status
= check_nonce(push_cert
.buf
, bogs
);
779 if (!is_null_oid(&push_cert_oid
)) {
780 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT=%s",
781 oid_to_hex(&push_cert_oid
));
782 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT_SIGNER=%s",
783 sigcheck
.signer
? sigcheck
.signer
: "");
784 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT_KEY=%s",
785 sigcheck
.key
? sigcheck
.key
: "");
786 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT_STATUS=%c",
788 if (push_cert_nonce
) {
789 strvec_pushf(&proc
->env
,
790 "GIT_PUSH_CERT_NONCE=%s",
792 strvec_pushf(&proc
->env
,
793 "GIT_PUSH_CERT_NONCE_STATUS=%s",
795 if (nonce_status
== NONCE_SLOP
)
796 strvec_pushf(&proc
->env
,
797 "GIT_PUSH_CERT_NONCE_SLOP=%ld",
803 struct receive_hook_feed_state
{
805 struct ref_push_report
*report
;
808 const struct string_list
*push_options
;
811 typedef int (*feed_fn
)(void *, const char **, size_t *);
812 static int run_and_feed_hook(const char *hook_name
, feed_fn feed
,
813 struct receive_hook_feed_state
*feed_state
)
815 struct child_process proc
= CHILD_PROCESS_INIT
;
818 const char *hook_path
= find_hook(hook_name
);
823 strvec_push(&proc
.args
, hook_path
);
825 proc
.stdout_to_stderr
= 1;
826 proc
.trace2_hook_name
= hook_name
;
828 if (feed_state
->push_options
) {
830 for (i
= 0; i
< feed_state
->push_options
->nr
; i
++)
831 strvec_pushf(&proc
.env
,
832 "GIT_PUSH_OPTION_%"PRIuMAX
"=%s",
834 feed_state
->push_options
->items
[i
].string
);
835 strvec_pushf(&proc
.env
, "GIT_PUSH_OPTION_COUNT=%"PRIuMAX
"",
836 (uintmax_t)feed_state
->push_options
->nr
);
838 strvec_pushf(&proc
.env
, "GIT_PUSH_OPTION_COUNT");
841 strvec_pushv(&proc
.env
, tmp_objdir_env(tmp_objdir
));
844 memset(&muxer
, 0, sizeof(muxer
));
845 muxer
.proc
= copy_to_sideband
;
847 code
= start_async(&muxer
);
853 prepare_push_cert_sha1(&proc
);
855 code
= start_command(&proc
);
858 finish_async(&muxer
);
862 sigchain_push(SIGPIPE
, SIG_IGN
);
867 if (feed(feed_state
, &buf
, &n
))
869 if (write_in_full(proc
.in
, buf
, n
) < 0)
874 finish_async(&muxer
);
876 sigchain_pop(SIGPIPE
);
878 return finish_command(&proc
);
881 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
883 struct receive_hook_feed_state
*state
= state_
;
884 struct command
*cmd
= state
->cmd
;
887 state
->skip_broken
&& (cmd
->error_string
|| cmd
->did_not_exist
))
892 return 0; /* OK, can feed something. */
893 strbuf_reset(&state
->buf
);
895 state
->report
= cmd
->report
;
897 struct object_id
*old_oid
;
898 struct object_id
*new_oid
;
899 const char *ref_name
;
901 old_oid
= state
->report
->old_oid
? state
->report
->old_oid
: &cmd
->old_oid
;
902 new_oid
= state
->report
->new_oid
? state
->report
->new_oid
: &cmd
->new_oid
;
903 ref_name
= state
->report
->ref_name
? state
->report
->ref_name
: cmd
->ref_name
;
904 strbuf_addf(&state
->buf
, "%s %s %s\n",
905 oid_to_hex(old_oid
), oid_to_hex(new_oid
),
907 state
->report
= state
->report
->next
;
909 state
->cmd
= cmd
->next
;
911 strbuf_addf(&state
->buf
, "%s %s %s\n",
912 oid_to_hex(&cmd
->old_oid
), oid_to_hex(&cmd
->new_oid
),
914 state
->cmd
= cmd
->next
;
917 *bufp
= state
->buf
.buf
;
918 *sizep
= state
->buf
.len
;
923 static int run_receive_hook(struct command
*commands
,
924 const char *hook_name
,
926 const struct string_list
*push_options
)
928 struct receive_hook_feed_state state
;
931 strbuf_init(&state
.buf
, 0);
932 state
.cmd
= commands
;
933 state
.skip_broken
= skip_broken
;
935 if (feed_receive_hook(&state
, NULL
, NULL
))
937 state
.cmd
= commands
;
938 state
.push_options
= push_options
;
939 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
940 strbuf_release(&state
.buf
);
944 static int run_update_hook(struct command
*cmd
)
946 struct child_process proc
= CHILD_PROCESS_INIT
;
948 const char *hook_path
= find_hook("update");
953 strvec_push(&proc
.args
, hook_path
);
954 strvec_push(&proc
.args
, cmd
->ref_name
);
955 strvec_push(&proc
.args
, oid_to_hex(&cmd
->old_oid
));
956 strvec_push(&proc
.args
, oid_to_hex(&cmd
->new_oid
));
959 proc
.stdout_to_stderr
= 1;
960 proc
.err
= use_sideband
? -1 : 0;
961 proc
.trace2_hook_name
= "update";
963 code
= start_command(&proc
);
967 copy_to_sideband(proc
.err
, -1, NULL
);
968 return finish_command(&proc
);
971 static struct command
*find_command_by_refname(struct command
*list
,
974 for (; list
; list
= list
->next
)
975 if (!strcmp(list
->ref_name
, refname
))
980 static int read_proc_receive_report(struct packet_reader
*reader
,
981 struct command
*commands
,
982 struct strbuf
*errmsg
)
985 struct command
*hint
= NULL
;
986 struct ref_push_report
*report
= NULL
;
993 struct object_id old_oid
, new_oid
;
997 enum packet_read_status status
;
999 status
= packet_reader_read(reader
);
1000 if (status
!= PACKET_READ_NORMAL
) {
1001 /* Check whether proc-receive exited abnormally */
1002 if (status
== PACKET_READ_EOF
&& !response
) {
1003 strbuf_addstr(errmsg
, "proc-receive exited abnormally");
1010 head
= reader
->line
;
1011 p
= strchr(head
, ' ');
1013 strbuf_addf(errmsg
, "proc-receive reported incomplete status line: '%s'\n", head
);
1018 if (!strcmp(head
, "option")) {
1019 const char *key
, *val
;
1021 if (!hint
|| !(report
|| new_report
)) {
1023 strbuf_addstr(errmsg
, "proc-receive reported 'option' without a matching 'ok/ng' directive\n");
1028 if (!hint
->report
) {
1029 CALLOC_ARRAY(hint
->report
, 1);
1030 report
= hint
->report
;
1032 report
= hint
->report
;
1033 while (report
->next
)
1034 report
= report
->next
;
1035 report
->next
= xcalloc(1, sizeof(struct ref_push_report
));
1036 report
= report
->next
;
1041 p
= strchr(key
, ' ');
1045 if (!strcmp(key
, "refname"))
1046 report
->ref_name
= xstrdup_or_null(val
);
1047 else if (!strcmp(key
, "old-oid") && val
&&
1048 !parse_oid_hex(val
, &old_oid
, &val
))
1049 report
->old_oid
= oiddup(&old_oid
);
1050 else if (!strcmp(key
, "new-oid") && val
&&
1051 !parse_oid_hex(val
, &new_oid
, &val
))
1052 report
->new_oid
= oiddup(&new_oid
);
1053 else if (!strcmp(key
, "forced-update"))
1054 report
->forced_update
= 1;
1055 else if (!strcmp(key
, "fall-through"))
1056 /* Fall through, let 'receive-pack' to execute it. */
1057 hint
->run_proc_receive
= 0;
1064 p
= strchr(refname
, ' ');
1067 if (strcmp(head
, "ok") && strcmp(head
, "ng")) {
1068 strbuf_addf(errmsg
, "proc-receive reported bad status '%s' on ref '%s'\n",
1074 /* first try searching at our hint, falling back to all refs */
1076 hint
= find_command_by_refname(hint
, refname
);
1078 hint
= find_command_by_refname(commands
, refname
);
1080 strbuf_addf(errmsg
, "proc-receive reported status on unknown ref: %s\n",
1085 if (!hint
->run_proc_receive
) {
1086 strbuf_addf(errmsg
, "proc-receive reported status on unexpected ref: %s\n",
1091 hint
->run_proc_receive
|= RUN_PROC_RECEIVE_RETURNED
;
1092 if (!strcmp(head
, "ng")) {
1094 hint
->error_string
= xstrdup(p
);
1096 hint
->error_string
= "failed";
1103 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1104 if (cmd
->run_proc_receive
&& !cmd
->error_string
&&
1105 !(cmd
->run_proc_receive
& RUN_PROC_RECEIVE_RETURNED
)) {
1106 cmd
->error_string
= "proc-receive failed to report status";
1112 static int run_proc_receive_hook(struct command
*commands
,
1113 const struct string_list
*push_options
)
1115 struct child_process proc
= CHILD_PROCESS_INIT
;
1117 struct command
*cmd
;
1118 struct packet_reader reader
;
1119 struct strbuf cap
= STRBUF_INIT
;
1120 struct strbuf errmsg
= STRBUF_INIT
;
1121 int hook_use_push_options
= 0;
1124 const char *hook_path
= find_hook("proc-receive");
1127 rp_error("cannot find hook 'proc-receive'");
1131 strvec_push(&proc
.args
, hook_path
);
1134 proc
.trace2_hook_name
= "proc-receive";
1137 memset(&muxer
, 0, sizeof(muxer
));
1138 muxer
.proc
= copy_to_sideband
;
1140 code
= start_async(&muxer
);
1143 proc
.err
= muxer
.in
;
1148 code
= start_command(&proc
);
1151 finish_async(&muxer
);
1155 sigchain_push(SIGPIPE
, SIG_IGN
);
1157 /* Version negotiaton */
1158 packet_reader_init(&reader
, proc
.out
, NULL
, 0,
1159 PACKET_READ_CHOMP_NEWLINE
|
1160 PACKET_READ_GENTLE_ON_EOF
);
1162 strbuf_addstr(&cap
, " atomic");
1163 if (use_push_options
)
1164 strbuf_addstr(&cap
, " push-options");
1166 code
= packet_write_fmt_gently(proc
.in
, "version=1%c%s\n", '\0', cap
.buf
+ 1);
1167 strbuf_release(&cap
);
1169 code
= packet_write_fmt_gently(proc
.in
, "version=1\n");
1172 code
= packet_flush_gently(proc
.in
);
1177 enum packet_read_status status
;
1179 status
= packet_reader_read(&reader
);
1180 if (status
!= PACKET_READ_NORMAL
) {
1181 /* Check whether proc-receive exited abnormally */
1182 if (status
== PACKET_READ_EOF
)
1187 if (reader
.pktlen
> 8 && starts_with(reader
.line
, "version=")) {
1188 version
= atoi(reader
.line
+ 8);
1189 linelen
= strlen(reader
.line
);
1190 if (linelen
< reader
.pktlen
) {
1191 const char *feature_list
= reader
.line
+ linelen
+ 1;
1192 if (parse_feature_request(feature_list
, "push-options"))
1193 hook_use_push_options
= 1;
1199 strbuf_addstr(&errmsg
, "fail to negotiate version with proc-receive hook");
1209 strbuf_addf(&errmsg
, "proc-receive version '%d' is not supported",
1216 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1217 if (!cmd
->run_proc_receive
|| cmd
->skip_update
|| cmd
->error_string
)
1219 code
= packet_write_fmt_gently(proc
.in
, "%s %s %s",
1220 oid_to_hex(&cmd
->old_oid
),
1221 oid_to_hex(&cmd
->new_oid
),
1227 code
= packet_flush_gently(proc
.in
);
1229 strbuf_addstr(&errmsg
, "fail to write commands to proc-receive hook");
1233 /* Send push options */
1234 if (hook_use_push_options
) {
1235 struct string_list_item
*item
;
1237 for_each_string_list_item(item
, push_options
) {
1238 code
= packet_write_fmt_gently(proc
.in
, "%s", item
->string
);
1243 code
= packet_flush_gently(proc
.in
);
1245 strbuf_addstr(&errmsg
,
1246 "fail to write push-options to proc-receive hook");
1251 /* Read result from proc-receive */
1252 code
= read_proc_receive_report(&reader
, commands
, &errmsg
);
1258 finish_async(&muxer
);
1259 if (finish_command(&proc
))
1261 if (errmsg
.len
>0) {
1262 char *p
= errmsg
.buf
;
1264 p
+= errmsg
.len
- 1;
1267 rp_error("%s", errmsg
.buf
);
1268 strbuf_release(&errmsg
);
1270 sigchain_pop(SIGPIPE
);
1275 static char *refuse_unconfigured_deny_msg
=
1276 N_("By default, updating the current branch in a non-bare repository\n"
1277 "is denied, because it will make the index and work tree inconsistent\n"
1278 "with what you pushed, and will require 'git reset --hard' to match\n"
1279 "the work tree to HEAD.\n"
1281 "You can set the 'receive.denyCurrentBranch' configuration variable\n"
1282 "to 'ignore' or 'warn' in the remote repository to allow pushing into\n"
1283 "its current branch; however, this is not recommended unless you\n"
1284 "arranged to update its work tree to match what you pushed in some\n"
1287 "To squelch this message and still keep the default behaviour, set\n"
1288 "'receive.denyCurrentBranch' configuration variable to 'refuse'.");
1290 static void refuse_unconfigured_deny(void)
1292 rp_error("%s", _(refuse_unconfigured_deny_msg
));
1295 static char *refuse_unconfigured_deny_delete_current_msg
=
1296 N_("By default, deleting the current branch is denied, because the next\n"
1297 "'git clone' won't result in any file checked out, causing confusion.\n"
1299 "You can set 'receive.denyDeleteCurrent' configuration variable to\n"
1300 "'warn' or 'ignore' in the remote repository to allow deleting the\n"
1301 "current branch, with or without a warning message.\n"
1303 "To squelch this message, you can set it to 'refuse'.");
1305 static void refuse_unconfigured_deny_delete_current(void)
1307 rp_error("%s", _(refuse_unconfigured_deny_delete_current_msg
));
1310 static const struct object_id
*command_singleton_iterator(void *cb_data
);
1311 static int update_shallow_ref(struct command
*cmd
, struct shallow_info
*si
)
1313 struct shallow_lock shallow_lock
= SHALLOW_LOCK_INIT
;
1314 struct oid_array extra
= OID_ARRAY_INIT
;
1315 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1316 uint32_t mask
= 1 << (cmd
->index
% 32);
1319 trace_printf_key(&trace_shallow
,
1320 "shallow: update_shallow_ref %s\n", cmd
->ref_name
);
1321 for (i
= 0; i
< si
->shallow
->nr
; i
++)
1322 if (si
->used_shallow
[i
] &&
1323 (si
->used_shallow
[i
][cmd
->index
/ 32] & mask
) &&
1324 !delayed_reachability_test(si
, i
))
1325 oid_array_append(&extra
, &si
->shallow
->oid
[i
]);
1327 opt
.env
= tmp_objdir_env(tmp_objdir
);
1328 setup_alternate_shallow(&shallow_lock
, &opt
.shallow_file
, &extra
);
1329 if (check_connected(command_singleton_iterator
, cmd
, &opt
)) {
1330 rollback_shallow_file(the_repository
, &shallow_lock
);
1331 oid_array_clear(&extra
);
1335 commit_shallow_file(the_repository
, &shallow_lock
);
1338 * Make sure setup_alternate_shallow() for the next ref does
1339 * not lose these new roots..
1341 for (i
= 0; i
< extra
.nr
; i
++)
1342 register_shallow(the_repository
, &extra
.oid
[i
]);
1344 si
->shallow_ref
[cmd
->index
] = 0;
1345 oid_array_clear(&extra
);
1350 * NEEDSWORK: we should consolidate various implementions of "are we
1351 * on an unborn branch?" test into one, and make the unified one more
1352 * robust. !get_sha1() based check used here and elsewhere would not
1353 * allow us to tell an unborn branch from corrupt ref, for example.
1354 * For the purpose of fixing "deploy-to-update does not work when
1355 * pushing into an empty repository" issue, this should suffice for
1358 static int head_has_history(void)
1360 struct object_id oid
;
1362 return !repo_get_oid(the_repository
, "HEAD", &oid
);
1365 static const char *push_to_deploy(unsigned char *sha1
,
1367 const char *work_tree
)
1369 struct child_process child
= CHILD_PROCESS_INIT
;
1371 strvec_pushl(&child
.args
, "update-index", "-q", "--ignore-submodules",
1373 strvec_pushv(&child
.env
, env
->v
);
1374 child
.dir
= work_tree
;
1376 child
.stdout_to_stderr
= 1;
1378 if (run_command(&child
))
1379 return "Up-to-date check failed";
1381 /* run_command() does not clean up completely; reinitialize */
1382 child_process_init(&child
);
1383 strvec_pushl(&child
.args
, "diff-files", "--quiet",
1384 "--ignore-submodules", "--", NULL
);
1385 strvec_pushv(&child
.env
, env
->v
);
1386 child
.dir
= work_tree
;
1388 child
.stdout_to_stderr
= 1;
1390 if (run_command(&child
))
1391 return "Working directory has unstaged changes";
1393 child_process_init(&child
);
1394 strvec_pushl(&child
.args
, "diff-index", "--quiet", "--cached",
1395 "--ignore-submodules",
1396 /* diff-index with either HEAD or an empty tree */
1397 head_has_history() ? "HEAD" : empty_tree_oid_hex(),
1399 strvec_pushv(&child
.env
, env
->v
);
1401 child
.no_stdout
= 1;
1402 child
.stdout_to_stderr
= 0;
1404 if (run_command(&child
))
1405 return "Working directory has staged changes";
1407 child_process_init(&child
);
1408 strvec_pushl(&child
.args
, "read-tree", "-u", "-m", hash_to_hex(sha1
),
1410 strvec_pushv(&child
.env
, env
->v
);
1411 child
.dir
= work_tree
;
1413 child
.no_stdout
= 1;
1414 child
.stdout_to_stderr
= 0;
1416 if (run_command(&child
))
1417 return "Could not update working tree to new HEAD";
1422 static const char *push_to_checkout_hook
= "push-to-checkout";
1424 static const char *push_to_checkout(unsigned char *hash
,
1427 const char *work_tree
)
1429 struct run_hooks_opt opt
= RUN_HOOKS_OPT_INIT
;
1430 opt
.invoked_hook
= invoked_hook
;
1432 strvec_pushf(env
, "GIT_WORK_TREE=%s", absolute_path(work_tree
));
1433 strvec_pushv(&opt
.env
, env
->v
);
1434 strvec_push(&opt
.args
, hash_to_hex(hash
));
1435 if (run_hooks_opt(push_to_checkout_hook
, &opt
))
1436 return "push-to-checkout hook declined";
1441 static const char *update_worktree(unsigned char *sha1
, const struct worktree
*worktree
)
1443 const char *retval
, *git_dir
;
1444 struct strvec env
= STRVEC_INIT
;
1447 if (!worktree
|| !worktree
->path
)
1448 BUG("worktree->path must be non-NULL");
1450 if (worktree
->is_bare
)
1451 return "denyCurrentBranch = updateInstead needs a worktree";
1452 git_dir
= get_worktree_git_dir(worktree
);
1454 strvec_pushf(&env
, "GIT_DIR=%s", absolute_path(git_dir
));
1456 retval
= push_to_checkout(sha1
, &invoked_hook
, &env
, worktree
->path
);
1458 retval
= push_to_deploy(sha1
, &env
, worktree
->path
);
1464 static const char *update(struct command
*cmd
, struct shallow_info
*si
)
1466 const char *name
= cmd
->ref_name
;
1467 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
1468 static char *namespaced_name
;
1470 struct object_id
*old_oid
= &cmd
->old_oid
;
1471 struct object_id
*new_oid
= &cmd
->new_oid
;
1472 int do_update_worktree
= 0;
1473 struct worktree
**worktrees
= get_worktrees();
1474 const struct worktree
*worktree
=
1475 find_shared_symref(worktrees
, "HEAD", name
);
1477 /* only refs/... are allowed */
1478 if (!starts_with(name
, "refs/") ||
1479 check_refname_format(name
+ 5, is_null_oid(new_oid
) ?
1480 REFNAME_ALLOW_ONELEVEL
: 0)) {
1481 rp_error("refusing to update funny ref '%s' remotely", name
);
1482 ret
= "funny refname";
1486 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
1487 free(namespaced_name
);
1488 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
1490 if (worktree
&& !worktree
->is_bare
) {
1491 switch (deny_current_branch
) {
1495 rp_warning("updating the current branch");
1498 case DENY_UNCONFIGURED
:
1499 rp_error("refusing to update checked out branch: %s", name
);
1500 if (deny_current_branch
== DENY_UNCONFIGURED
)
1501 refuse_unconfigured_deny();
1502 ret
= "branch is currently checked out";
1504 case DENY_UPDATE_INSTEAD
:
1505 /* pass -- let other checks intervene first */
1506 do_update_worktree
= 1;
1511 if (!is_null_oid(new_oid
) && !repo_has_object_file(the_repository
, new_oid
)) {
1512 error("unpack should have generated %s, "
1513 "but I can't find it!", oid_to_hex(new_oid
));
1518 if (!is_null_oid(old_oid
) && is_null_oid(new_oid
)) {
1519 if (deny_deletes
&& starts_with(name
, "refs/heads/")) {
1520 rp_error("denying ref deletion for %s", name
);
1521 ret
= "deletion prohibited";
1525 if (worktree
|| (head_name
&& !strcmp(namespaced_name
, head_name
))) {
1526 switch (deny_delete_current
) {
1530 rp_warning("deleting the current branch");
1533 case DENY_UNCONFIGURED
:
1534 case DENY_UPDATE_INSTEAD
:
1535 if (deny_delete_current
== DENY_UNCONFIGURED
)
1536 refuse_unconfigured_deny_delete_current();
1537 rp_error("refusing to delete the current branch: %s", name
);
1538 ret
= "deletion of the current branch prohibited";
1541 ret
= "Invalid denyDeleteCurrent setting";
1547 if (deny_non_fast_forwards
&& !is_null_oid(new_oid
) &&
1548 !is_null_oid(old_oid
) &&
1549 starts_with(name
, "refs/heads/")) {
1550 struct object
*old_object
, *new_object
;
1551 struct commit
*old_commit
, *new_commit
;
1553 old_object
= parse_object(the_repository
, old_oid
);
1554 new_object
= parse_object(the_repository
, new_oid
);
1556 if (!old_object
|| !new_object
||
1557 old_object
->type
!= OBJ_COMMIT
||
1558 new_object
->type
!= OBJ_COMMIT
) {
1559 error("bad sha1 objects for %s", name
);
1563 old_commit
= (struct commit
*)old_object
;
1564 new_commit
= (struct commit
*)new_object
;
1565 if (!repo_in_merge_bases(the_repository
, old_commit
, new_commit
)) {
1566 rp_error("denying non-fast-forward %s"
1567 " (you should pull first)", name
);
1568 ret
= "non-fast-forward";
1572 if (run_update_hook(cmd
)) {
1573 rp_error("hook declined to update %s", name
);
1574 ret
= "hook declined";
1578 if (do_update_worktree
) {
1579 ret
= update_worktree(new_oid
->hash
, worktree
);
1584 if (is_null_oid(new_oid
)) {
1585 struct strbuf err
= STRBUF_INIT
;
1586 if (!parse_object(the_repository
, old_oid
)) {
1588 if (ref_exists(name
)) {
1589 rp_warning("allowing deletion of corrupt ref");
1591 rp_warning("deleting a non-existent ref");
1592 cmd
->did_not_exist
= 1;
1595 if (ref_transaction_delete(transaction
,
1599 rp_error("%s", err
.buf
);
1600 ret
= "failed to delete";
1602 ret
= NULL
; /* good */
1604 strbuf_release(&err
);
1607 struct strbuf err
= STRBUF_INIT
;
1608 if (shallow_update
&& si
->shallow_ref
[cmd
->index
] &&
1609 update_shallow_ref(cmd
, si
)) {
1610 ret
= "shallow error";
1614 if (ref_transaction_update(transaction
,
1619 rp_error("%s", err
.buf
);
1620 ret
= "failed to update ref";
1622 ret
= NULL
; /* good */
1624 strbuf_release(&err
);
1628 free_worktrees(worktrees
);
1632 static void run_update_post_hook(struct command
*commands
)
1634 struct command
*cmd
;
1635 struct child_process proc
= CHILD_PROCESS_INIT
;
1638 hook
= find_hook("post-update");
1642 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1643 if (cmd
->error_string
|| cmd
->did_not_exist
)
1646 strvec_push(&proc
.args
, hook
);
1647 strvec_push(&proc
.args
, cmd
->ref_name
);
1653 proc
.stdout_to_stderr
= 1;
1654 proc
.err
= use_sideband
? -1 : 0;
1655 proc
.trace2_hook_name
= "post-update";
1657 if (!start_command(&proc
)) {
1659 copy_to_sideband(proc
.err
, -1, NULL
);
1660 finish_command(&proc
);
1664 static void check_aliased_update_internal(struct command
*cmd
,
1665 struct string_list
*list
,
1666 const char *dst_name
, int flag
)
1668 struct string_list_item
*item
;
1669 struct command
*dst_cmd
;
1671 if (!(flag
& REF_ISSYMREF
))
1675 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
1676 cmd
->skip_update
= 1;
1677 cmd
->error_string
= "broken symref";
1680 dst_name
= strip_namespace(dst_name
);
1682 if (!(item
= string_list_lookup(list
, dst_name
)))
1685 cmd
->skip_update
= 1;
1687 dst_cmd
= (struct command
*) item
->util
;
1689 if (oideq(&cmd
->old_oid
, &dst_cmd
->old_oid
) &&
1690 oideq(&cmd
->new_oid
, &dst_cmd
->new_oid
))
1693 dst_cmd
->skip_update
= 1;
1695 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1696 " its target '%s' (%s..%s)",
1698 repo_find_unique_abbrev(the_repository
, &cmd
->old_oid
, DEFAULT_ABBREV
),
1699 repo_find_unique_abbrev(the_repository
, &cmd
->new_oid
, DEFAULT_ABBREV
),
1701 repo_find_unique_abbrev(the_repository
, &dst_cmd
->old_oid
, DEFAULT_ABBREV
),
1702 repo_find_unique_abbrev(the_repository
, &dst_cmd
->new_oid
, DEFAULT_ABBREV
));
1704 cmd
->error_string
= dst_cmd
->error_string
=
1705 "inconsistent aliased update";
1708 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
1710 struct strbuf buf
= STRBUF_INIT
;
1711 const char *dst_name
;
1714 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
1715 dst_name
= resolve_ref_unsafe(buf
.buf
, 0, NULL
, &flag
);
1716 check_aliased_update_internal(cmd
, list
, dst_name
, flag
);
1717 strbuf_release(&buf
);
1720 static void check_aliased_updates(struct command
*commands
)
1722 struct command
*cmd
;
1723 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
1725 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1726 struct string_list_item
*item
=
1727 string_list_append(&ref_list
, cmd
->ref_name
);
1728 item
->util
= (void *)cmd
;
1730 string_list_sort(&ref_list
);
1732 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1733 if (!cmd
->error_string
)
1734 check_aliased_update(cmd
, &ref_list
);
1737 string_list_clear(&ref_list
, 0);
1740 static const struct object_id
*command_singleton_iterator(void *cb_data
)
1742 struct command
**cmd_list
= cb_data
;
1743 struct command
*cmd
= *cmd_list
;
1745 if (!cmd
|| is_null_oid(&cmd
->new_oid
))
1747 *cmd_list
= NULL
; /* this returns only one */
1748 return &cmd
->new_oid
;
1751 static void set_connectivity_errors(struct command
*commands
,
1752 struct shallow_info
*si
)
1754 struct command
*cmd
;
1756 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1757 struct command
*singleton
= cmd
;
1758 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1760 if (shallow_update
&& si
->shallow_ref
[cmd
->index
])
1761 /* to be checked in update_shallow_ref() */
1764 opt
.env
= tmp_objdir_env(tmp_objdir
);
1765 if (!check_connected(command_singleton_iterator
, &singleton
,
1769 cmd
->error_string
= "missing necessary objects";
1773 struct iterate_data
{
1774 struct command
*cmds
;
1775 struct shallow_info
*si
;
1778 static const struct object_id
*iterate_receive_command_list(void *cb_data
)
1780 struct iterate_data
*data
= cb_data
;
1781 struct command
**cmd_list
= &data
->cmds
;
1782 struct command
*cmd
= *cmd_list
;
1784 for (; cmd
; cmd
= cmd
->next
) {
1785 if (shallow_update
&& data
->si
->shallow_ref
[cmd
->index
])
1786 /* to be checked in update_shallow_ref() */
1788 if (!is_null_oid(&cmd
->new_oid
) && !cmd
->skip_update
) {
1789 *cmd_list
= cmd
->next
;
1790 return &cmd
->new_oid
;
1796 static void reject_updates_to_hidden(struct command
*commands
)
1798 struct strbuf refname_full
= STRBUF_INIT
;
1800 struct command
*cmd
;
1802 strbuf_addstr(&refname_full
, get_git_namespace());
1803 prefix_len
= refname_full
.len
;
1805 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1806 if (cmd
->error_string
)
1809 strbuf_setlen(&refname_full
, prefix_len
);
1810 strbuf_addstr(&refname_full
, cmd
->ref_name
);
1812 if (!ref_is_hidden(cmd
->ref_name
, refname_full
.buf
, &hidden_refs
))
1814 if (is_null_oid(&cmd
->new_oid
))
1815 cmd
->error_string
= "deny deleting a hidden ref";
1817 cmd
->error_string
= "deny updating a hidden ref";
1820 strbuf_release(&refname_full
);
1823 static int should_process_cmd(struct command
*cmd
)
1825 return !cmd
->error_string
&& !cmd
->skip_update
;
1828 static void BUG_if_skipped_connectivity_check(struct command
*commands
,
1829 struct shallow_info
*si
)
1831 struct command
*cmd
;
1833 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1834 if (should_process_cmd(cmd
) && si
->shallow_ref
[cmd
->index
])
1835 bug("connectivity check has not been run on ref %s",
1838 BUG_if_bug("connectivity check skipped???");
1841 static void execute_commands_non_atomic(struct command
*commands
,
1842 struct shallow_info
*si
)
1844 struct command
*cmd
;
1845 struct strbuf err
= STRBUF_INIT
;
1847 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1848 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1851 transaction
= ref_transaction_begin(&err
);
1853 rp_error("%s", err
.buf
);
1855 cmd
->error_string
= "transaction failed to start";
1859 cmd
->error_string
= update(cmd
, si
);
1861 if (!cmd
->error_string
1862 && ref_transaction_commit(transaction
, &err
)) {
1863 rp_error("%s", err
.buf
);
1865 cmd
->error_string
= "failed to update ref";
1867 ref_transaction_free(transaction
);
1869 strbuf_release(&err
);
1872 static void execute_commands_atomic(struct command
*commands
,
1873 struct shallow_info
*si
)
1875 struct command
*cmd
;
1876 struct strbuf err
= STRBUF_INIT
;
1877 const char *reported_error
= "atomic push failure";
1879 transaction
= ref_transaction_begin(&err
);
1881 rp_error("%s", err
.buf
);
1883 reported_error
= "transaction failed to start";
1887 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1888 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1891 cmd
->error_string
= update(cmd
, si
);
1893 if (cmd
->error_string
)
1897 if (ref_transaction_commit(transaction
, &err
)) {
1898 rp_error("%s", err
.buf
);
1899 reported_error
= "atomic transaction failed";
1905 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1906 if (!cmd
->error_string
)
1907 cmd
->error_string
= reported_error
;
1910 ref_transaction_free(transaction
);
1911 strbuf_release(&err
);
1914 static void execute_commands(struct command
*commands
,
1915 const char *unpacker_error
,
1916 struct shallow_info
*si
,
1917 const struct string_list
*push_options
)
1919 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1920 struct command
*cmd
;
1921 struct iterate_data data
;
1924 int run_proc_receive
= 0;
1926 if (unpacker_error
) {
1927 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1928 cmd
->error_string
= "unpacker error";
1933 memset(&muxer
, 0, sizeof(muxer
));
1934 muxer
.proc
= copy_to_sideband
;
1936 if (!start_async(&muxer
))
1938 /* ...else, continue without relaying sideband */
1941 data
.cmds
= commands
;
1943 opt
.err_fd
= err_fd
;
1944 opt
.progress
= err_fd
&& !quiet
;
1945 opt
.env
= tmp_objdir_env(tmp_objdir
);
1946 opt
.exclude_hidden_refs_section
= "receive";
1948 if (check_connected(iterate_receive_command_list
, &data
, &opt
))
1949 set_connectivity_errors(commands
, si
);
1952 finish_async(&muxer
);
1954 reject_updates_to_hidden(commands
);
1957 * Try to find commands that have special prefix in their reference names,
1958 * and mark them to run an external "proc-receive" hook later.
1960 if (proc_receive_ref
) {
1961 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1962 if (!should_process_cmd(cmd
))
1965 if (proc_receive_ref_matches(cmd
)) {
1966 cmd
->run_proc_receive
= RUN_PROC_RECEIVE_SCHEDULED
;
1967 run_proc_receive
= 1;
1972 if (run_receive_hook(commands
, "pre-receive", 0, push_options
)) {
1973 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1974 if (!cmd
->error_string
)
1975 cmd
->error_string
= "pre-receive hook declined";
1981 * If there is no command ready to run, should return directly to destroy
1982 * temporary data in the quarantine area.
1984 for (cmd
= commands
; cmd
&& cmd
->error_string
; cmd
= cmd
->next
)
1990 * Now we'll start writing out refs, which means the objects need
1991 * to be in their final positions so that other processes can see them.
1993 if (tmp_objdir_migrate(tmp_objdir
) < 0) {
1994 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1995 if (!cmd
->error_string
)
1996 cmd
->error_string
= "unable to migrate objects to permanent storage";
2002 check_aliased_updates(commands
);
2004 free(head_name_to_free
);
2005 head_name
= head_name_to_free
= resolve_refdup("HEAD", 0, NULL
, NULL
);
2007 if (run_proc_receive
&&
2008 run_proc_receive_hook(commands
, push_options
))
2009 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
2010 if (!cmd
->error_string
&&
2011 !(cmd
->run_proc_receive
& RUN_PROC_RECEIVE_RETURNED
) &&
2012 (cmd
->run_proc_receive
|| use_atomic
))
2013 cmd
->error_string
= "fail to run proc-receive hook";
2016 execute_commands_atomic(commands
, si
);
2018 execute_commands_non_atomic(commands
, si
);
2021 BUG_if_skipped_connectivity_check(commands
, si
);
2024 static struct command
**queue_command(struct command
**tail
,
2028 struct object_id old_oid
, new_oid
;
2029 struct command
*cmd
;
2030 const char *refname
;
2034 if (parse_oid_hex(line
, &old_oid
, &p
) ||
2036 parse_oid_hex(p
, &new_oid
, &p
) ||
2038 die("protocol error: expected old/new/ref, got '%s'", line
);
2041 reflen
= linelen
- (p
- line
);
2042 FLEX_ALLOC_MEM(cmd
, ref_name
, refname
, reflen
);
2043 oidcpy(&cmd
->old_oid
, &old_oid
);
2044 oidcpy(&cmd
->new_oid
, &new_oid
);
2049 static void free_commands(struct command
*commands
)
2052 struct command
*next
= commands
->next
;
2059 static void queue_commands_from_cert(struct command
**tail
,
2060 struct strbuf
*push_cert
)
2062 const char *boc
, *eoc
;
2065 die("protocol error: got both push certificate and unsigned commands");
2067 boc
= strstr(push_cert
->buf
, "\n\n");
2069 die("malformed push certificate %.*s", 100, push_cert
->buf
);
2072 eoc
= push_cert
->buf
+ parse_signed_buffer(push_cert
->buf
, push_cert
->len
);
2075 const char *eol
= memchr(boc
, '\n', eoc
- boc
);
2076 tail
= queue_command(tail
, boc
, eol
? eol
- boc
: eoc
- boc
);
2077 boc
= eol
? eol
+ 1 : eoc
;
2081 static struct command
*read_head_info(struct packet_reader
*reader
,
2082 struct oid_array
*shallow
)
2084 struct command
*commands
= NULL
;
2085 struct command
**p
= &commands
;
2089 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
2092 if (reader
->pktlen
> 8 && starts_with(reader
->line
, "shallow ")) {
2093 struct object_id oid
;
2094 if (get_oid_hex(reader
->line
+ 8, &oid
))
2095 die("protocol error: expected shallow sha, got '%s'",
2097 oid_array_append(shallow
, &oid
);
2101 linelen
= strlen(reader
->line
);
2102 if (linelen
< reader
->pktlen
) {
2103 const char *feature_list
= reader
->line
+ linelen
+ 1;
2104 const char *hash
= NULL
;
2105 const char *client_sid
;
2107 if (parse_feature_request(feature_list
, "report-status"))
2109 if (parse_feature_request(feature_list
, "report-status-v2"))
2110 report_status_v2
= 1;
2111 if (parse_feature_request(feature_list
, "side-band-64k"))
2112 use_sideband
= LARGE_PACKET_MAX
;
2113 if (parse_feature_request(feature_list
, "quiet"))
2115 if (advertise_atomic_push
2116 && parse_feature_request(feature_list
, "atomic"))
2118 if (advertise_push_options
2119 && parse_feature_request(feature_list
, "push-options"))
2120 use_push_options
= 1;
2121 hash
= parse_feature_value(feature_list
, "object-format", &len
, NULL
);
2123 hash
= hash_algos
[GIT_HASH_SHA1
].name
;
2126 if (xstrncmpz(the_hash_algo
->name
, hash
, len
))
2127 die("error: unsupported object format '%s'", hash
);
2128 client_sid
= parse_feature_value(feature_list
, "session-id", &len
, NULL
);
2130 char *sid
= xstrndup(client_sid
, len
);
2131 trace2_data_string("transfer", NULL
, "client-sid", client_sid
);
2136 if (!strcmp(reader
->line
, "push-cert")) {
2138 int saved_options
= reader
->options
;
2139 reader
->options
&= ~PACKET_READ_CHOMP_NEWLINE
;
2142 packet_reader_read(reader
);
2143 if (reader
->status
== PACKET_READ_FLUSH
) {
2147 if (reader
->status
!= PACKET_READ_NORMAL
) {
2148 die("protocol error: got an unexpected packet");
2150 if (!strcmp(reader
->line
, "push-cert-end\n"))
2151 break; /* end of cert */
2152 strbuf_addstr(&push_cert
, reader
->line
);
2154 reader
->options
= saved_options
;
2161 p
= queue_command(p
, reader
->line
, linelen
);
2165 queue_commands_from_cert(p
, &push_cert
);
2170 static void read_push_options(struct packet_reader
*reader
,
2171 struct string_list
*options
)
2174 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
2177 string_list_append(options
, reader
->line
);
2181 static const char *parse_pack_header(struct pack_header
*hdr
)
2183 switch (read_pack_header(0, hdr
)) {
2185 return "eof before pack header was fully read";
2187 case PH_ERROR_PACK_SIGNATURE
:
2188 return "protocol error (pack signature mismatch detected)";
2190 case PH_ERROR_PROTOCOL
:
2191 return "protocol error (pack version unsupported)";
2194 return "unknown error in parse_pack_header";
2201 static struct tempfile
*pack_lockfile
;
2203 static void push_header_arg(struct strvec
*args
, struct pack_header
*hdr
)
2205 strvec_pushf(args
, "--pack_header=%"PRIu32
",%"PRIu32
,
2206 ntohl(hdr
->hdr_version
), ntohl(hdr
->hdr_entries
));
2209 static const char *unpack(int err_fd
, struct shallow_info
*si
)
2211 struct pack_header hdr
;
2212 const char *hdr_err
;
2214 struct child_process child
= CHILD_PROCESS_INIT
;
2215 int fsck_objects
= (receive_fsck_objects
>= 0
2216 ? receive_fsck_objects
2217 : transfer_fsck_objects
>= 0
2218 ? transfer_fsck_objects
2221 hdr_err
= parse_pack_header(&hdr
);
2228 if (si
->nr_ours
|| si
->nr_theirs
) {
2229 alt_shallow_file
= setup_temporary_shallow(si
->shallow
);
2230 strvec_push(&child
.args
, "--shallow-file");
2231 strvec_push(&child
.args
, alt_shallow_file
);
2234 tmp_objdir
= tmp_objdir_create("incoming");
2238 return "unable to create temporary object directory";
2240 strvec_pushv(&child
.env
, tmp_objdir_env(tmp_objdir
));
2243 * Normally we just pass the tmp_objdir environment to the child
2244 * processes that do the heavy lifting, but we may need to see these
2245 * objects ourselves to set up shallow information.
2247 tmp_objdir_add_as_alternate(tmp_objdir
);
2249 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
2250 strvec_push(&child
.args
, "unpack-objects");
2251 push_header_arg(&child
.args
, &hdr
);
2253 strvec_push(&child
.args
, "-q");
2255 strvec_pushf(&child
.args
, "--strict%s",
2256 fsck_msg_types
.buf
);
2258 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2259 (uintmax_t)max_input_size
);
2260 child
.no_stdout
= 1;
2263 status
= run_command(&child
);
2265 return "unpack-objects abnormal exit";
2267 char hostname
[HOST_NAME_MAX
+ 1];
2270 strvec_pushl(&child
.args
, "index-pack", "--stdin", NULL
);
2271 push_header_arg(&child
.args
, &hdr
);
2273 if (xgethostname(hostname
, sizeof(hostname
)))
2274 xsnprintf(hostname
, sizeof(hostname
), "localhost");
2275 strvec_pushf(&child
.args
,
2276 "--keep=receive-pack %"PRIuMAX
" on %s",
2277 (uintmax_t)getpid(),
2280 if (!quiet
&& err_fd
)
2281 strvec_push(&child
.args
, "--show-resolving-progress");
2283 strvec_push(&child
.args
, "--report-end-of-input");
2285 strvec_pushf(&child
.args
, "--strict%s",
2286 fsck_msg_types
.buf
);
2288 strvec_push(&child
.args
, "--fix-thin");
2290 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2291 (uintmax_t)max_input_size
);
2295 status
= start_command(&child
);
2297 return "index-pack fork failed";
2299 lockfile
= index_pack_lockfile(child
.out
, NULL
);
2301 pack_lockfile
= register_tempfile(lockfile
);
2306 status
= finish_command(&child
);
2308 return "index-pack abnormal exit";
2309 reprepare_packed_git(the_repository
);
2314 static const char *unpack_with_sideband(struct shallow_info
*si
)
2320 return unpack(0, si
);
2322 use_keepalive
= KEEPALIVE_AFTER_NUL
;
2323 memset(&muxer
, 0, sizeof(muxer
));
2324 muxer
.proc
= copy_to_sideband
;
2326 if (start_async(&muxer
))
2329 ret
= unpack(muxer
.in
, si
);
2331 finish_async(&muxer
);
2335 static void prepare_shallow_update(struct shallow_info
*si
)
2337 int i
, j
, k
, bitmap_size
= DIV_ROUND_UP(si
->ref
->nr
, 32);
2339 ALLOC_ARRAY(si
->used_shallow
, si
->shallow
->nr
);
2340 assign_shallow_commits_to_refs(si
, si
->used_shallow
, NULL
);
2342 CALLOC_ARRAY(si
->need_reachability_test
, si
->shallow
->nr
);
2343 CALLOC_ARRAY(si
->reachable
, si
->shallow
->nr
);
2344 CALLOC_ARRAY(si
->shallow_ref
, si
->ref
->nr
);
2346 for (i
= 0; i
< si
->nr_ours
; i
++)
2347 si
->need_reachability_test
[si
->ours
[i
]] = 1;
2349 for (i
= 0; i
< si
->shallow
->nr
; i
++) {
2350 if (!si
->used_shallow
[i
])
2352 for (j
= 0; j
< bitmap_size
; j
++) {
2353 if (!si
->used_shallow
[i
][j
])
2355 si
->need_reachability_test
[i
]++;
2356 for (k
= 0; k
< 32; k
++)
2357 if (si
->used_shallow
[i
][j
] & (1U << k
))
2358 si
->shallow_ref
[j
* 32 + k
]++;
2362 * true for those associated with some refs and belong
2363 * in "ours" list aka "step 7 not done yet"
2365 si
->need_reachability_test
[i
] =
2366 si
->need_reachability_test
[i
] > 1;
2370 * keep hooks happy by forcing a temporary shallow file via
2371 * env variable because we can't add --shallow-file to every
2372 * command. check_connected() will be done with
2373 * true .git/shallow though.
2375 setenv(GIT_SHALLOW_FILE_ENVIRONMENT
, alt_shallow_file
, 1);
2378 static void update_shallow_info(struct command
*commands
,
2379 struct shallow_info
*si
,
2380 struct oid_array
*ref
)
2382 struct command
*cmd
;
2384 remove_nonexistent_theirs_shallow(si
);
2385 if (!si
->nr_ours
&& !si
->nr_theirs
) {
2390 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2391 if (is_null_oid(&cmd
->new_oid
))
2393 oid_array_append(ref
, &cmd
->new_oid
);
2394 cmd
->index
= ref
->nr
- 1;
2398 if (shallow_update
) {
2399 prepare_shallow_update(si
);
2403 ALLOC_ARRAY(ref_status
, ref
->nr
);
2404 assign_shallow_commits_to_refs(si
, NULL
, ref_status
);
2405 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2406 if (is_null_oid(&cmd
->new_oid
))
2408 if (ref_status
[cmd
->index
]) {
2409 cmd
->error_string
= "shallow update not allowed";
2410 cmd
->skip_update
= 1;
2416 static void report(struct command
*commands
, const char *unpack_status
)
2418 struct command
*cmd
;
2419 struct strbuf buf
= STRBUF_INIT
;
2421 packet_buf_write(&buf
, "unpack %s\n",
2422 unpack_status
? unpack_status
: "ok");
2423 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2424 if (!cmd
->error_string
)
2425 packet_buf_write(&buf
, "ok %s\n",
2428 packet_buf_write(&buf
, "ng %s %s\n",
2429 cmd
->ref_name
, cmd
->error_string
);
2431 packet_buf_flush(&buf
);
2434 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2436 write_or_die(1, buf
.buf
, buf
.len
);
2437 strbuf_release(&buf
);
2440 static void report_v2(struct command
*commands
, const char *unpack_status
)
2442 struct command
*cmd
;
2443 struct strbuf buf
= STRBUF_INIT
;
2444 struct ref_push_report
*report
;
2446 packet_buf_write(&buf
, "unpack %s\n",
2447 unpack_status
? unpack_status
: "ok");
2448 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2451 if (cmd
->error_string
) {
2452 packet_buf_write(&buf
, "ng %s %s\n",
2457 packet_buf_write(&buf
, "ok %s\n",
2459 for (report
= cmd
->report
; report
; report
= report
->next
) {
2461 packet_buf_write(&buf
, "ok %s\n",
2463 if (report
->ref_name
)
2464 packet_buf_write(&buf
, "option refname %s\n",
2466 if (report
->old_oid
)
2467 packet_buf_write(&buf
, "option old-oid %s\n",
2468 oid_to_hex(report
->old_oid
));
2469 if (report
->new_oid
)
2470 packet_buf_write(&buf
, "option new-oid %s\n",
2471 oid_to_hex(report
->new_oid
));
2472 if (report
->forced_update
)
2473 packet_buf_write(&buf
, "option forced-update\n");
2476 packet_buf_flush(&buf
);
2479 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2481 write_or_die(1, buf
.buf
, buf
.len
);
2482 strbuf_release(&buf
);
2485 static int delete_only(struct command
*commands
)
2487 struct command
*cmd
;
2488 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2489 if (!is_null_oid(&cmd
->new_oid
))
2495 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
2497 int advertise_refs
= 0;
2498 struct command
*commands
;
2499 struct oid_array shallow
= OID_ARRAY_INIT
;
2500 struct oid_array ref
= OID_ARRAY_INIT
;
2501 struct shallow_info si
;
2502 struct packet_reader reader
;
2504 struct option options
[] = {
2505 OPT__QUIET(&quiet
, N_("quiet")),
2506 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc
, NULL
),
2507 OPT_HIDDEN_BOOL(0, "http-backend-info-refs", &advertise_refs
, NULL
),
2508 OPT_ALIAS(0, "advertise-refs", "http-backend-info-refs"),
2509 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin
, NULL
),
2513 packet_trace_identity("receive-pack");
2515 argc
= parse_options(argc
, argv
, prefix
, options
, receive_pack_usage
, 0);
2518 usage_msg_opt(_("too many arguments"), receive_pack_usage
, options
);
2520 usage_msg_opt(_("you must specify a directory"), receive_pack_usage
, options
);
2522 service_dir
= argv
[0];
2526 if (!enter_repo(service_dir
, 0))
2527 die("'%s' does not appear to be a git repository", service_dir
);
2529 git_config(receive_pack_config
, NULL
);
2530 if (cert_nonce_seed
)
2531 push_cert_nonce
= prepare_push_cert_nonce(service_dir
, time(NULL
));
2533 if (0 <= receive_unpack_limit
)
2534 unpack_limit
= receive_unpack_limit
;
2535 else if (0 <= transfer_unpack_limit
)
2536 unpack_limit
= transfer_unpack_limit
;
2538 switch (determine_protocol_version_server()) {
2541 * push support for protocol v2 has not been implemented yet,
2542 * so ignore the request to use v2 and fallback to using v0.
2547 * v1 is just the original protocol with a version string,
2548 * so just fall through after writing the version string.
2550 if (advertise_refs
|| !stateless_rpc
)
2551 packet_write_fmt(1, "version 1\n");
2556 case protocol_unknown_version
:
2557 BUG("unknown protocol version");
2560 if (advertise_refs
|| !stateless_rpc
) {
2566 packet_reader_init(&reader
, 0, NULL
, 0,
2567 PACKET_READ_CHOMP_NEWLINE
|
2568 PACKET_READ_DIE_ON_ERR_PACKET
);
2570 if ((commands
= read_head_info(&reader
, &shallow
))) {
2571 const char *unpack_status
= NULL
;
2572 struct string_list push_options
= STRING_LIST_INIT_DUP
;
2574 if (use_push_options
)
2575 read_push_options(&reader
, &push_options
);
2576 if (!check_cert_push_options(&push_options
)) {
2577 struct command
*cmd
;
2578 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
2579 cmd
->error_string
= "inconsistent push options";
2582 prepare_shallow_info(&si
, &shallow
);
2583 if (!si
.nr_ours
&& !si
.nr_theirs
)
2585 if (!delete_only(commands
)) {
2586 unpack_status
= unpack_with_sideband(&si
);
2587 update_shallow_info(commands
, &si
, &ref
);
2589 use_keepalive
= KEEPALIVE_ALWAYS
;
2590 execute_commands(commands
, unpack_status
, &si
,
2592 delete_tempfile(&pack_lockfile
);
2593 sigchain_push(SIGPIPE
, SIG_IGN
);
2594 if (report_status_v2
)
2595 report_v2(commands
, unpack_status
);
2596 else if (report_status
)
2597 report(commands
, unpack_status
);
2598 sigchain_pop(SIGPIPE
);
2599 run_receive_hook(commands
, "post-receive", 1,
2601 run_update_post_hook(commands
);
2602 free_commands(commands
);
2603 string_list_clear(&push_options
, 0);
2605 struct child_process proc
= CHILD_PROCESS_INIT
;
2608 proc
.stdout_to_stderr
= 1;
2609 proc
.err
= use_sideband
? -1 : 0;
2610 proc
.git_cmd
= proc
.close_object_store
= 1;
2611 strvec_pushl(&proc
.args
, "gc", "--auto", "--quiet",
2614 if (!start_command(&proc
)) {
2616 copy_to_sideband(proc
.err
, -1, NULL
);
2617 finish_command(&proc
);
2620 if (auto_update_server_info
)
2621 update_server_info(0);
2622 clear_shallow_info(&si
);
2626 oid_array_clear(&shallow
);
2627 oid_array_clear(&ref
);
2628 strvec_clear(&hidden_refs
);
2629 free((void *)push_cert_nonce
);