2 #include "repository.h"
10 #include "run-command.h"
17 #include "string-list.h"
18 #include "oid-array.h"
19 #include "connected.h"
23 #include "gpg-interface.h"
26 #include "tmp-objdir.h"
29 #include "object-store.h"
31 #include "commit-reach.h"
35 static const char * const receive_pack_usage
[] = {
36 N_("git receive-pack <git-dir>"),
48 static int deny_deletes
;
49 static int deny_non_fast_forwards
;
50 static enum deny_action deny_current_branch
= DENY_UNCONFIGURED
;
51 static enum deny_action deny_delete_current
= DENY_UNCONFIGURED
;
52 static int receive_fsck_objects
= -1;
53 static int transfer_fsck_objects
= -1;
54 static struct strbuf fsck_msg_types
= STRBUF_INIT
;
55 static int receive_unpack_limit
= -1;
56 static int transfer_unpack_limit
= -1;
57 static int advertise_atomic_push
= 1;
58 static int advertise_push_options
;
59 static int advertise_sid
;
60 static int unpack_limit
= 100;
61 static off_t max_input_size
;
62 static int report_status
;
63 static int report_status_v2
;
64 static int use_sideband
;
65 static int use_atomic
;
66 static int use_push_options
;
68 static int prefer_ofs_delta
= 1;
69 static int auto_update_server_info
;
70 static int auto_gc
= 1;
71 static int reject_thin
;
72 static int stateless_rpc
;
73 static const char *service_dir
;
74 static const char *head_name
;
75 static void *head_name_to_free
;
76 static int sent_capabilities
;
77 static int shallow_update
;
78 static const char *alt_shallow_file
;
79 static struct strbuf push_cert
= STRBUF_INIT
;
80 static struct object_id push_cert_oid
;
81 static struct signature_check sigcheck
;
82 static const char *push_cert_nonce
;
83 static const char *cert_nonce_seed
;
84 static struct string_list hidden_refs
= STRING_LIST_INIT_DUP
;
86 static const char *NONCE_UNSOLICITED
= "UNSOLICITED";
87 static const char *NONCE_BAD
= "BAD";
88 static const char *NONCE_MISSING
= "MISSING";
89 static const char *NONCE_OK
= "OK";
90 static const char *NONCE_SLOP
= "SLOP";
91 static const char *nonce_status
;
92 static long nonce_stamp_slop
;
93 static timestamp_t nonce_stamp_slop_limit
;
94 static struct ref_transaction
*transaction
;
101 static int keepalive_in_sec
= 5;
103 static struct tmp_objdir
*tmp_objdir
;
105 static struct proc_receive_ref
{
106 unsigned int want_add
:1,
111 struct proc_receive_ref
*next
;
114 static void proc_receive_ref_append(const char *prefix
);
116 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
119 if (!strcasecmp(value
, "ignore"))
121 if (!strcasecmp(value
, "warn"))
123 if (!strcasecmp(value
, "refuse"))
125 if (!strcasecmp(value
, "updateinstead"))
126 return DENY_UPDATE_INSTEAD
;
128 if (git_config_bool(var
, value
))
133 static int receive_pack_config(const char *var
, const char *value
, void *cb
)
135 int status
= parse_hide_refs_config(var
, value
, "receive", &hidden_refs
);
140 if (strcmp(var
, "receive.denydeletes") == 0) {
141 deny_deletes
= git_config_bool(var
, value
);
145 if (strcmp(var
, "receive.denynonfastforwards") == 0) {
146 deny_non_fast_forwards
= git_config_bool(var
, value
);
150 if (strcmp(var
, "receive.unpacklimit") == 0) {
151 receive_unpack_limit
= git_config_int(var
, value
);
155 if (strcmp(var
, "transfer.unpacklimit") == 0) {
156 transfer_unpack_limit
= git_config_int(var
, value
);
160 if (strcmp(var
, "receive.fsck.skiplist") == 0) {
163 if (git_config_pathname(&path
, var
, value
))
165 strbuf_addf(&fsck_msg_types
, "%cskiplist=%s",
166 fsck_msg_types
.len
? ',' : '=', path
);
171 if (skip_prefix(var
, "receive.fsck.", &var
)) {
172 if (is_valid_msg_type(var
, value
))
173 strbuf_addf(&fsck_msg_types
, "%c%s=%s",
174 fsck_msg_types
.len
? ',' : '=', var
, value
);
176 warning("skipping unknown msg id '%s'", var
);
180 if (strcmp(var
, "receive.fsckobjects") == 0) {
181 receive_fsck_objects
= git_config_bool(var
, value
);
185 if (strcmp(var
, "transfer.fsckobjects") == 0) {
186 transfer_fsck_objects
= git_config_bool(var
, value
);
190 if (!strcmp(var
, "receive.denycurrentbranch")) {
191 deny_current_branch
= parse_deny_action(var
, value
);
195 if (strcmp(var
, "receive.denydeletecurrent") == 0) {
196 deny_delete_current
= parse_deny_action(var
, value
);
200 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
201 prefer_ofs_delta
= git_config_bool(var
, value
);
205 if (strcmp(var
, "receive.updateserverinfo") == 0) {
206 auto_update_server_info
= git_config_bool(var
, value
);
210 if (strcmp(var
, "receive.autogc") == 0) {
211 auto_gc
= git_config_bool(var
, value
);
215 if (strcmp(var
, "receive.shallowupdate") == 0) {
216 shallow_update
= git_config_bool(var
, value
);
220 if (strcmp(var
, "receive.certnonceseed") == 0)
221 return git_config_string(&cert_nonce_seed
, var
, value
);
223 if (strcmp(var
, "receive.certnonceslop") == 0) {
224 nonce_stamp_slop_limit
= git_config_ulong(var
, value
);
228 if (strcmp(var
, "receive.advertiseatomic") == 0) {
229 advertise_atomic_push
= git_config_bool(var
, value
);
233 if (strcmp(var
, "receive.advertisepushoptions") == 0) {
234 advertise_push_options
= git_config_bool(var
, value
);
238 if (strcmp(var
, "receive.keepalive") == 0) {
239 keepalive_in_sec
= git_config_int(var
, value
);
243 if (strcmp(var
, "receive.maxinputsize") == 0) {
244 max_input_size
= git_config_int64(var
, value
);
248 if (strcmp(var
, "receive.procreceiverefs") == 0) {
250 return config_error_nonbool(var
);
251 proc_receive_ref_append(value
);
255 if (strcmp(var
, "transfer.advertisesid") == 0) {
256 advertise_sid
= git_config_bool(var
, value
);
260 return git_default_config(var
, value
, cb
);
263 static void show_ref(const char *path
, const struct object_id
*oid
)
265 if (sent_capabilities
) {
266 packet_write_fmt(1, "%s %s\n", oid_to_hex(oid
), path
);
268 struct strbuf cap
= STRBUF_INIT
;
271 "report-status report-status-v2 delete-refs side-band-64k quiet");
272 if (advertise_atomic_push
)
273 strbuf_addstr(&cap
, " atomic");
274 if (prefer_ofs_delta
)
275 strbuf_addstr(&cap
, " ofs-delta");
277 strbuf_addf(&cap
, " push-cert=%s", push_cert_nonce
);
278 if (advertise_push_options
)
279 strbuf_addstr(&cap
, " push-options");
281 strbuf_addf(&cap
, " session-id=%s", trace2_session_id());
282 strbuf_addf(&cap
, " object-format=%s", the_hash_algo
->name
);
283 strbuf_addf(&cap
, " agent=%s", git_user_agent_sanitized());
284 packet_write_fmt(1, "%s %s%c%s\n",
285 oid_to_hex(oid
), path
, 0, cap
.buf
);
286 strbuf_release(&cap
);
287 sent_capabilities
= 1;
291 static int show_ref_cb(const char *path_full
, const struct object_id
*oid
,
292 int flag UNUSED
, void *data
)
294 struct oidset
*seen
= data
;
295 const char *path
= strip_namespace(path_full
);
297 if (ref_is_hidden(path
, path_full
, &hidden_refs
))
301 * Advertise refs outside our current namespace as ".have"
302 * refs, so that the client can use them to minimize data
303 * transfer but will otherwise ignore them.
306 if (oidset_insert(seen
, oid
))
310 oidset_insert(seen
, oid
);
316 static void show_one_alternate_ref(const struct object_id
*oid
,
319 struct oidset
*seen
= data
;
321 if (oidset_insert(seen
, oid
))
324 show_ref(".have", oid
);
327 static void write_head_info(void)
329 static struct oidset seen
= OIDSET_INIT
;
331 for_each_ref(show_ref_cb
, &seen
);
332 for_each_alternate_ref(show_one_alternate_ref
, &seen
);
334 if (!sent_capabilities
)
335 show_ref("capabilities^{}", null_oid());
337 advertise_shallow_grafts(1);
343 #define RUN_PROC_RECEIVE_SCHEDULED 1
344 #define RUN_PROC_RECEIVE_RETURNED 2
346 struct command
*next
;
347 const char *error_string
;
348 struct ref_push_report
*report
;
349 unsigned int skip_update
:1,
353 struct object_id old_oid
;
354 struct object_id new_oid
;
355 char ref_name
[FLEX_ARRAY
]; /* more */
358 static void proc_receive_ref_append(const char *prefix
)
360 struct proc_receive_ref
*ref_pattern
;
364 CALLOC_ARRAY(ref_pattern
, 1);
365 p
= strchr(prefix
, ':');
369 ref_pattern
->want_add
= 1;
370 else if (*prefix
== 'd')
371 ref_pattern
->want_delete
= 1;
372 else if (*prefix
== 'm')
373 ref_pattern
->want_modify
= 1;
374 else if (*prefix
== '!')
375 ref_pattern
->negative_ref
= 1;
380 ref_pattern
->want_add
= 1;
381 ref_pattern
->want_delete
= 1;
382 ref_pattern
->want_modify
= 1;
384 len
= strlen(prefix
);
385 while (len
&& prefix
[len
- 1] == '/')
387 ref_pattern
->ref_prefix
= xmemdupz(prefix
, len
);
388 if (!proc_receive_ref
) {
389 proc_receive_ref
= ref_pattern
;
391 struct proc_receive_ref
*end
;
393 end
= proc_receive_ref
;
396 end
->next
= ref_pattern
;
400 static int proc_receive_ref_matches(struct command
*cmd
)
402 struct proc_receive_ref
*p
;
404 if (!proc_receive_ref
)
407 for (p
= proc_receive_ref
; p
; p
= p
->next
) {
408 const char *match
= p
->ref_prefix
;
411 if (!p
->want_add
&& is_null_oid(&cmd
->old_oid
))
413 else if (!p
->want_delete
&& is_null_oid(&cmd
->new_oid
))
415 else if (!p
->want_modify
&&
416 !is_null_oid(&cmd
->old_oid
) &&
417 !is_null_oid(&cmd
->new_oid
))
420 if (skip_prefix(cmd
->ref_name
, match
, &remains
) &&
421 (!*remains
|| *remains
== '/')) {
422 if (!p
->negative_ref
)
424 } else if (p
->negative_ref
) {
431 static void report_message(const char *prefix
, const char *err
, va_list params
)
436 sz
= xsnprintf(msg
, sizeof(msg
), "%s", prefix
);
437 sz
+= vsnprintf(msg
+ sz
, sizeof(msg
) - sz
, err
, params
);
438 if (sz
> (sizeof(msg
) - 1))
439 sz
= sizeof(msg
) - 1;
443 send_sideband(1, 2, msg
, sz
, use_sideband
);
448 __attribute__((format (printf
, 1, 2)))
449 static void rp_warning(const char *err
, ...)
452 va_start(params
, err
);
453 report_message("warning: ", err
, params
);
457 __attribute__((format (printf
, 1, 2)))
458 static void rp_error(const char *err
, ...)
461 va_start(params
, err
);
462 report_message("error: ", err
, params
);
466 static int copy_to_sideband(int in
, int out UNUSED
, void *arg UNUSED
)
469 int keepalive_active
= 0;
471 if (keepalive_in_sec
<= 0)
472 use_keepalive
= KEEPALIVE_NEVER
;
473 if (use_keepalive
== KEEPALIVE_ALWAYS
)
474 keepalive_active
= 1;
479 if (keepalive_active
) {
485 ret
= poll(&pfd
, 1, 1000 * keepalive_in_sec
);
492 } else if (ret
== 0) {
493 /* no data; send a keepalive packet */
494 static const char buf
[] = "0005\1";
495 write_or_die(1, buf
, sizeof(buf
) - 1);
497 } /* else there is actual data to read */
500 sz
= xread(in
, data
, sizeof(data
));
504 if (use_keepalive
== KEEPALIVE_AFTER_NUL
&& !keepalive_active
) {
505 const char *p
= memchr(data
, '\0', sz
);
508 * The NUL tells us to start sending keepalives. Make
509 * sure we send any other data we read along
512 keepalive_active
= 1;
513 send_sideband(1, 2, data
, p
- data
, use_sideband
);
514 send_sideband(1, 2, p
+ 1, sz
- (p
- data
+ 1), use_sideband
);
520 * Either we're not looking for a NUL signal, or we didn't see
521 * it yet; just pass along the data.
523 send_sideband(1, 2, data
, sz
, use_sideband
);
529 static void hmac_hash(unsigned char *out
,
530 const char *key_in
, size_t key_len
,
531 const char *text
, size_t text_len
)
533 unsigned char key
[GIT_MAX_BLKSZ
];
534 unsigned char k_ipad
[GIT_MAX_BLKSZ
];
535 unsigned char k_opad
[GIT_MAX_BLKSZ
];
539 /* RFC 2104 2. (1) */
540 memset(key
, '\0', GIT_MAX_BLKSZ
);
541 if (the_hash_algo
->blksz
< key_len
) {
542 the_hash_algo
->init_fn(&ctx
);
543 the_hash_algo
->update_fn(&ctx
, key_in
, key_len
);
544 the_hash_algo
->final_fn(key
, &ctx
);
546 memcpy(key
, key_in
, key_len
);
549 /* RFC 2104 2. (2) & (5) */
550 for (i
= 0; i
< sizeof(key
); i
++) {
551 k_ipad
[i
] = key
[i
] ^ 0x36;
552 k_opad
[i
] = key
[i
] ^ 0x5c;
555 /* RFC 2104 2. (3) & (4) */
556 the_hash_algo
->init_fn(&ctx
);
557 the_hash_algo
->update_fn(&ctx
, k_ipad
, sizeof(k_ipad
));
558 the_hash_algo
->update_fn(&ctx
, text
, text_len
);
559 the_hash_algo
->final_fn(out
, &ctx
);
561 /* RFC 2104 2. (6) & (7) */
562 the_hash_algo
->init_fn(&ctx
);
563 the_hash_algo
->update_fn(&ctx
, k_opad
, sizeof(k_opad
));
564 the_hash_algo
->update_fn(&ctx
, out
, the_hash_algo
->rawsz
);
565 the_hash_algo
->final_fn(out
, &ctx
);
568 static char *prepare_push_cert_nonce(const char *path
, timestamp_t stamp
)
570 struct strbuf buf
= STRBUF_INIT
;
571 unsigned char hash
[GIT_MAX_RAWSZ
];
573 strbuf_addf(&buf
, "%s:%"PRItime
, path
, stamp
);
574 hmac_hash(hash
, buf
.buf
, buf
.len
, cert_nonce_seed
, strlen(cert_nonce_seed
));
575 strbuf_release(&buf
);
577 /* RFC 2104 5. HMAC-SHA1 or HMAC-SHA256 */
578 strbuf_addf(&buf
, "%"PRItime
"-%.*s", stamp
, (int)the_hash_algo
->hexsz
, hash_to_hex(hash
));
579 return strbuf_detach(&buf
, NULL
);
582 static char *find_header(const char *msg
, size_t len
, const char *key
,
583 const char **next_line
)
586 const char *val
= find_header_mem(msg
, len
, key
, &out_len
);
592 *next_line
= val
+ out_len
+ 1;
594 return xmemdupz(val
, out_len
);
598 * Return zero if a and b are equal up to n bytes and nonzero if they are not.
599 * This operation is guaranteed to run in constant time to avoid leaking data.
601 static int constant_memequal(const char *a
, const char *b
, size_t n
)
606 for (i
= 0; i
< n
; i
++)
611 static const char *check_nonce(const char *buf
, size_t len
)
613 char *nonce
= find_header(buf
, len
, "nonce", NULL
);
614 timestamp_t stamp
, ostamp
;
615 char *bohmac
, *expect
= NULL
;
616 const char *retval
= NONCE_BAD
;
620 retval
= NONCE_MISSING
;
622 } else if (!push_cert_nonce
) {
623 retval
= NONCE_UNSOLICITED
;
625 } else if (!strcmp(push_cert_nonce
, nonce
)) {
630 if (!stateless_rpc
) {
631 /* returned nonce MUST match what we gave out earlier */
637 * In stateless mode, we may be receiving a nonce issued by
638 * another instance of the server that serving the same
639 * repository, and the timestamps may not match, but the
640 * nonce-seed and dir should match, so we can recompute and
641 * report the time slop.
643 * In addition, when a nonce issued by another instance has
644 * timestamp within receive.certnonceslop seconds, we pretend
645 * as if we issued that nonce when reporting to the hook.
648 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
649 if (*nonce
<= '0' || '9' < *nonce
) {
653 stamp
= parse_timestamp(nonce
, &bohmac
, 10);
654 if (bohmac
== nonce
|| bohmac
[0] != '-') {
659 noncelen
= strlen(nonce
);
660 expect
= prepare_push_cert_nonce(service_dir
, stamp
);
661 if (noncelen
!= strlen(expect
)) {
662 /* This is not even the right size. */
666 if (constant_memequal(expect
, nonce
, noncelen
)) {
667 /* Not what we would have signed earlier */
673 * By how many seconds is this nonce stale? Negative value
674 * would mean it was issued by another server with its clock
675 * skewed in the future.
677 ostamp
= parse_timestamp(push_cert_nonce
, NULL
, 10);
678 nonce_stamp_slop
= (long)ostamp
- (long)stamp
;
680 if (nonce_stamp_slop_limit
&&
681 labs(nonce_stamp_slop
) <= nonce_stamp_slop_limit
) {
683 * Pretend as if the received nonce (which passes the
684 * HMAC check, so it is not a forged by third-party)
687 free((void *)push_cert_nonce
);
688 push_cert_nonce
= xstrdup(nonce
);
701 * Return 1 if there is no push_cert or if the push options in push_cert are
702 * the same as those in the argument; 0 otherwise.
704 static int check_cert_push_options(const struct string_list
*push_options
)
706 const char *buf
= push_cert
.buf
;
707 int len
= push_cert
.len
;
710 const char *next_line
;
711 int options_seen
= 0;
718 while ((option
= find_header(buf
, len
, "push-option", &next_line
))) {
719 len
-= (next_line
- buf
);
722 if (options_seen
> push_options
->nr
724 push_options
->items
[options_seen
- 1].string
)) {
731 if (options_seen
!= push_options
->nr
)
739 static void prepare_push_cert_sha1(struct child_process
*proc
)
741 static int already_done
;
747 int bogs
/* beginning_of_gpg_sig */;
750 if (write_object_file(push_cert
.buf
, push_cert
.len
, OBJ_BLOB
,
752 oidclr(&push_cert_oid
);
754 memset(&sigcheck
, '\0', sizeof(sigcheck
));
756 bogs
= parse_signed_buffer(push_cert
.buf
, push_cert
.len
);
757 sigcheck
.payload
= xmemdupz(push_cert
.buf
, bogs
);
758 sigcheck
.payload_len
= bogs
;
759 check_signature(&sigcheck
, push_cert
.buf
+ bogs
,
760 push_cert
.len
- bogs
);
762 nonce_status
= check_nonce(push_cert
.buf
, bogs
);
764 if (!is_null_oid(&push_cert_oid
)) {
765 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT=%s",
766 oid_to_hex(&push_cert_oid
));
767 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT_SIGNER=%s",
768 sigcheck
.signer
? sigcheck
.signer
: "");
769 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT_KEY=%s",
770 sigcheck
.key
? sigcheck
.key
: "");
771 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT_STATUS=%c",
773 if (push_cert_nonce
) {
774 strvec_pushf(&proc
->env
,
775 "GIT_PUSH_CERT_NONCE=%s",
777 strvec_pushf(&proc
->env
,
778 "GIT_PUSH_CERT_NONCE_STATUS=%s",
780 if (nonce_status
== NONCE_SLOP
)
781 strvec_pushf(&proc
->env
,
782 "GIT_PUSH_CERT_NONCE_SLOP=%ld",
788 struct receive_hook_feed_state
{
790 struct ref_push_report
*report
;
793 const struct string_list
*push_options
;
796 typedef int (*feed_fn
)(void *, const char **, size_t *);
797 static int run_and_feed_hook(const char *hook_name
, feed_fn feed
,
798 struct receive_hook_feed_state
*feed_state
)
800 struct child_process proc
= CHILD_PROCESS_INIT
;
803 const char *hook_path
= find_hook(hook_name
);
808 strvec_push(&proc
.args
, hook_path
);
810 proc
.stdout_to_stderr
= 1;
811 proc
.trace2_hook_name
= hook_name
;
813 if (feed_state
->push_options
) {
815 for (i
= 0; i
< feed_state
->push_options
->nr
; i
++)
816 strvec_pushf(&proc
.env
,
817 "GIT_PUSH_OPTION_%"PRIuMAX
"=%s",
819 feed_state
->push_options
->items
[i
].string
);
820 strvec_pushf(&proc
.env
, "GIT_PUSH_OPTION_COUNT=%"PRIuMAX
"",
821 (uintmax_t)feed_state
->push_options
->nr
);
823 strvec_pushf(&proc
.env
, "GIT_PUSH_OPTION_COUNT");
826 strvec_pushv(&proc
.env
, tmp_objdir_env(tmp_objdir
));
829 memset(&muxer
, 0, sizeof(muxer
));
830 muxer
.proc
= copy_to_sideband
;
832 code
= start_async(&muxer
);
838 prepare_push_cert_sha1(&proc
);
840 code
= start_command(&proc
);
843 finish_async(&muxer
);
847 sigchain_push(SIGPIPE
, SIG_IGN
);
852 if (feed(feed_state
, &buf
, &n
))
854 if (write_in_full(proc
.in
, buf
, n
) < 0)
859 finish_async(&muxer
);
861 sigchain_pop(SIGPIPE
);
863 return finish_command(&proc
);
866 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
868 struct receive_hook_feed_state
*state
= state_
;
869 struct command
*cmd
= state
->cmd
;
872 state
->skip_broken
&& (cmd
->error_string
|| cmd
->did_not_exist
))
877 return 0; /* OK, can feed something. */
878 strbuf_reset(&state
->buf
);
880 state
->report
= cmd
->report
;
882 struct object_id
*old_oid
;
883 struct object_id
*new_oid
;
884 const char *ref_name
;
886 old_oid
= state
->report
->old_oid
? state
->report
->old_oid
: &cmd
->old_oid
;
887 new_oid
= state
->report
->new_oid
? state
->report
->new_oid
: &cmd
->new_oid
;
888 ref_name
= state
->report
->ref_name
? state
->report
->ref_name
: cmd
->ref_name
;
889 strbuf_addf(&state
->buf
, "%s %s %s\n",
890 oid_to_hex(old_oid
), oid_to_hex(new_oid
),
892 state
->report
= state
->report
->next
;
894 state
->cmd
= cmd
->next
;
896 strbuf_addf(&state
->buf
, "%s %s %s\n",
897 oid_to_hex(&cmd
->old_oid
), oid_to_hex(&cmd
->new_oid
),
899 state
->cmd
= cmd
->next
;
902 *bufp
= state
->buf
.buf
;
903 *sizep
= state
->buf
.len
;
908 static int run_receive_hook(struct command
*commands
,
909 const char *hook_name
,
911 const struct string_list
*push_options
)
913 struct receive_hook_feed_state state
;
916 strbuf_init(&state
.buf
, 0);
917 state
.cmd
= commands
;
918 state
.skip_broken
= skip_broken
;
920 if (feed_receive_hook(&state
, NULL
, NULL
))
922 state
.cmd
= commands
;
923 state
.push_options
= push_options
;
924 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
925 strbuf_release(&state
.buf
);
929 static int run_update_hook(struct command
*cmd
)
931 struct child_process proc
= CHILD_PROCESS_INIT
;
933 const char *hook_path
= find_hook("update");
938 strvec_push(&proc
.args
, hook_path
);
939 strvec_push(&proc
.args
, cmd
->ref_name
);
940 strvec_push(&proc
.args
, oid_to_hex(&cmd
->old_oid
));
941 strvec_push(&proc
.args
, oid_to_hex(&cmd
->new_oid
));
944 proc
.stdout_to_stderr
= 1;
945 proc
.err
= use_sideband
? -1 : 0;
946 proc
.trace2_hook_name
= "update";
948 code
= start_command(&proc
);
952 copy_to_sideband(proc
.err
, -1, NULL
);
953 return finish_command(&proc
);
956 static struct command
*find_command_by_refname(struct command
*list
,
959 for (; list
; list
= list
->next
)
960 if (!strcmp(list
->ref_name
, refname
))
965 static int read_proc_receive_report(struct packet_reader
*reader
,
966 struct command
*commands
,
967 struct strbuf
*errmsg
)
970 struct command
*hint
= NULL
;
971 struct ref_push_report
*report
= NULL
;
978 struct object_id old_oid
, new_oid
;
982 enum packet_read_status status
;
984 status
= packet_reader_read(reader
);
985 if (status
!= PACKET_READ_NORMAL
) {
986 /* Check whether proc-receive exited abnormally */
987 if (status
== PACKET_READ_EOF
&& !response
) {
988 strbuf_addstr(errmsg
, "proc-receive exited abnormally");
996 p
= strchr(head
, ' ');
998 strbuf_addf(errmsg
, "proc-receive reported incomplete status line: '%s'\n", head
);
1003 if (!strcmp(head
, "option")) {
1004 const char *key
, *val
;
1006 if (!hint
|| !(report
|| new_report
)) {
1008 strbuf_addstr(errmsg
, "proc-receive reported 'option' without a matching 'ok/ng' directive\n");
1013 if (!hint
->report
) {
1014 CALLOC_ARRAY(hint
->report
, 1);
1015 report
= hint
->report
;
1017 report
= hint
->report
;
1018 while (report
->next
)
1019 report
= report
->next
;
1020 report
->next
= xcalloc(1, sizeof(struct ref_push_report
));
1021 report
= report
->next
;
1026 p
= strchr(key
, ' ');
1030 if (!strcmp(key
, "refname"))
1031 report
->ref_name
= xstrdup_or_null(val
);
1032 else if (!strcmp(key
, "old-oid") && val
&&
1033 !parse_oid_hex(val
, &old_oid
, &val
))
1034 report
->old_oid
= oiddup(&old_oid
);
1035 else if (!strcmp(key
, "new-oid") && val
&&
1036 !parse_oid_hex(val
, &new_oid
, &val
))
1037 report
->new_oid
= oiddup(&new_oid
);
1038 else if (!strcmp(key
, "forced-update"))
1039 report
->forced_update
= 1;
1040 else if (!strcmp(key
, "fall-through"))
1041 /* Fall through, let 'receive-pack' to execute it. */
1042 hint
->run_proc_receive
= 0;
1049 p
= strchr(refname
, ' ');
1052 if (strcmp(head
, "ok") && strcmp(head
, "ng")) {
1053 strbuf_addf(errmsg
, "proc-receive reported bad status '%s' on ref '%s'\n",
1059 /* first try searching at our hint, falling back to all refs */
1061 hint
= find_command_by_refname(hint
, refname
);
1063 hint
= find_command_by_refname(commands
, refname
);
1065 strbuf_addf(errmsg
, "proc-receive reported status on unknown ref: %s\n",
1070 if (!hint
->run_proc_receive
) {
1071 strbuf_addf(errmsg
, "proc-receive reported status on unexpected ref: %s\n",
1076 hint
->run_proc_receive
|= RUN_PROC_RECEIVE_RETURNED
;
1077 if (!strcmp(head
, "ng")) {
1079 hint
->error_string
= xstrdup(p
);
1081 hint
->error_string
= "failed";
1088 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1089 if (cmd
->run_proc_receive
&& !cmd
->error_string
&&
1090 !(cmd
->run_proc_receive
& RUN_PROC_RECEIVE_RETURNED
)) {
1091 cmd
->error_string
= "proc-receive failed to report status";
1097 static int run_proc_receive_hook(struct command
*commands
,
1098 const struct string_list
*push_options
)
1100 struct child_process proc
= CHILD_PROCESS_INIT
;
1102 struct command
*cmd
;
1103 struct packet_reader reader
;
1104 struct strbuf cap
= STRBUF_INIT
;
1105 struct strbuf errmsg
= STRBUF_INIT
;
1106 int hook_use_push_options
= 0;
1109 const char *hook_path
= find_hook("proc-receive");
1112 rp_error("cannot find hook 'proc-receive'");
1116 strvec_push(&proc
.args
, hook_path
);
1119 proc
.trace2_hook_name
= "proc-receive";
1122 memset(&muxer
, 0, sizeof(muxer
));
1123 muxer
.proc
= copy_to_sideband
;
1125 code
= start_async(&muxer
);
1128 proc
.err
= muxer
.in
;
1133 code
= start_command(&proc
);
1136 finish_async(&muxer
);
1140 sigchain_push(SIGPIPE
, SIG_IGN
);
1142 /* Version negotiaton */
1143 packet_reader_init(&reader
, proc
.out
, NULL
, 0,
1144 PACKET_READ_CHOMP_NEWLINE
|
1145 PACKET_READ_GENTLE_ON_EOF
);
1147 strbuf_addstr(&cap
, " atomic");
1148 if (use_push_options
)
1149 strbuf_addstr(&cap
, " push-options");
1151 code
= packet_write_fmt_gently(proc
.in
, "version=1%c%s\n", '\0', cap
.buf
+ 1);
1152 strbuf_release(&cap
);
1154 code
= packet_write_fmt_gently(proc
.in
, "version=1\n");
1157 code
= packet_flush_gently(proc
.in
);
1162 enum packet_read_status status
;
1164 status
= packet_reader_read(&reader
);
1165 if (status
!= PACKET_READ_NORMAL
) {
1166 /* Check whether proc-receive exited abnormally */
1167 if (status
== PACKET_READ_EOF
)
1172 if (reader
.pktlen
> 8 && starts_with(reader
.line
, "version=")) {
1173 version
= atoi(reader
.line
+ 8);
1174 linelen
= strlen(reader
.line
);
1175 if (linelen
< reader
.pktlen
) {
1176 const char *feature_list
= reader
.line
+ linelen
+ 1;
1177 if (parse_feature_request(feature_list
, "push-options"))
1178 hook_use_push_options
= 1;
1184 strbuf_addstr(&errmsg
, "fail to negotiate version with proc-receive hook");
1194 strbuf_addf(&errmsg
, "proc-receive version '%d' is not supported",
1201 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1202 if (!cmd
->run_proc_receive
|| cmd
->skip_update
|| cmd
->error_string
)
1204 code
= packet_write_fmt_gently(proc
.in
, "%s %s %s",
1205 oid_to_hex(&cmd
->old_oid
),
1206 oid_to_hex(&cmd
->new_oid
),
1212 code
= packet_flush_gently(proc
.in
);
1214 strbuf_addstr(&errmsg
, "fail to write commands to proc-receive hook");
1218 /* Send push options */
1219 if (hook_use_push_options
) {
1220 struct string_list_item
*item
;
1222 for_each_string_list_item(item
, push_options
) {
1223 code
= packet_write_fmt_gently(proc
.in
, "%s", item
->string
);
1228 code
= packet_flush_gently(proc
.in
);
1230 strbuf_addstr(&errmsg
,
1231 "fail to write push-options to proc-receive hook");
1236 /* Read result from proc-receive */
1237 code
= read_proc_receive_report(&reader
, commands
, &errmsg
);
1243 finish_async(&muxer
);
1244 if (finish_command(&proc
))
1246 if (errmsg
.len
>0) {
1247 char *p
= errmsg
.buf
;
1249 p
+= errmsg
.len
- 1;
1252 rp_error("%s", errmsg
.buf
);
1253 strbuf_release(&errmsg
);
1255 sigchain_pop(SIGPIPE
);
1260 static char *refuse_unconfigured_deny_msg
=
1261 N_("By default, updating the current branch in a non-bare repository\n"
1262 "is denied, because it will make the index and work tree inconsistent\n"
1263 "with what you pushed, and will require 'git reset --hard' to match\n"
1264 "the work tree to HEAD.\n"
1266 "You can set the 'receive.denyCurrentBranch' configuration variable\n"
1267 "to 'ignore' or 'warn' in the remote repository to allow pushing into\n"
1268 "its current branch; however, this is not recommended unless you\n"
1269 "arranged to update its work tree to match what you pushed in some\n"
1272 "To squelch this message and still keep the default behaviour, set\n"
1273 "'receive.denyCurrentBranch' configuration variable to 'refuse'.");
1275 static void refuse_unconfigured_deny(void)
1277 rp_error("%s", _(refuse_unconfigured_deny_msg
));
1280 static char *refuse_unconfigured_deny_delete_current_msg
=
1281 N_("By default, deleting the current branch is denied, because the next\n"
1282 "'git clone' won't result in any file checked out, causing confusion.\n"
1284 "You can set 'receive.denyDeleteCurrent' configuration variable to\n"
1285 "'warn' or 'ignore' in the remote repository to allow deleting the\n"
1286 "current branch, with or without a warning message.\n"
1288 "To squelch this message, you can set it to 'refuse'.");
1290 static void refuse_unconfigured_deny_delete_current(void)
1292 rp_error("%s", _(refuse_unconfigured_deny_delete_current_msg
));
1295 static const struct object_id
*command_singleton_iterator(void *cb_data
);
1296 static int update_shallow_ref(struct command
*cmd
, struct shallow_info
*si
)
1298 struct shallow_lock shallow_lock
= SHALLOW_LOCK_INIT
;
1299 struct oid_array extra
= OID_ARRAY_INIT
;
1300 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1301 uint32_t mask
= 1 << (cmd
->index
% 32);
1304 trace_printf_key(&trace_shallow
,
1305 "shallow: update_shallow_ref %s\n", cmd
->ref_name
);
1306 for (i
= 0; i
< si
->shallow
->nr
; i
++)
1307 if (si
->used_shallow
[i
] &&
1308 (si
->used_shallow
[i
][cmd
->index
/ 32] & mask
) &&
1309 !delayed_reachability_test(si
, i
))
1310 oid_array_append(&extra
, &si
->shallow
->oid
[i
]);
1312 opt
.env
= tmp_objdir_env(tmp_objdir
);
1313 setup_alternate_shallow(&shallow_lock
, &opt
.shallow_file
, &extra
);
1314 if (check_connected(command_singleton_iterator
, cmd
, &opt
)) {
1315 rollback_shallow_file(the_repository
, &shallow_lock
);
1316 oid_array_clear(&extra
);
1320 commit_shallow_file(the_repository
, &shallow_lock
);
1323 * Make sure setup_alternate_shallow() for the next ref does
1324 * not lose these new roots..
1326 for (i
= 0; i
< extra
.nr
; i
++)
1327 register_shallow(the_repository
, &extra
.oid
[i
]);
1329 si
->shallow_ref
[cmd
->index
] = 0;
1330 oid_array_clear(&extra
);
1335 * NEEDSWORK: we should consolidate various implementions of "are we
1336 * on an unborn branch?" test into one, and make the unified one more
1337 * robust. !get_sha1() based check used here and elsewhere would not
1338 * allow us to tell an unborn branch from corrupt ref, for example.
1339 * For the purpose of fixing "deploy-to-update does not work when
1340 * pushing into an empty repository" issue, this should suffice for
1343 static int head_has_history(void)
1345 struct object_id oid
;
1347 return !get_oid("HEAD", &oid
);
1350 static const char *push_to_deploy(unsigned char *sha1
,
1352 const char *work_tree
)
1354 struct child_process child
= CHILD_PROCESS_INIT
;
1356 strvec_pushl(&child
.args
, "update-index", "-q", "--ignore-submodules",
1358 strvec_pushv(&child
.env
, env
->v
);
1359 child
.dir
= work_tree
;
1361 child
.stdout_to_stderr
= 1;
1363 if (run_command(&child
))
1364 return "Up-to-date check failed";
1366 /* run_command() does not clean up completely; reinitialize */
1367 child_process_init(&child
);
1368 strvec_pushl(&child
.args
, "diff-files", "--quiet",
1369 "--ignore-submodules", "--", NULL
);
1370 strvec_pushv(&child
.env
, env
->v
);
1371 child
.dir
= work_tree
;
1373 child
.stdout_to_stderr
= 1;
1375 if (run_command(&child
))
1376 return "Working directory has unstaged changes";
1378 child_process_init(&child
);
1379 strvec_pushl(&child
.args
, "diff-index", "--quiet", "--cached",
1380 "--ignore-submodules",
1381 /* diff-index with either HEAD or an empty tree */
1382 head_has_history() ? "HEAD" : empty_tree_oid_hex(),
1384 strvec_pushv(&child
.env
, env
->v
);
1386 child
.no_stdout
= 1;
1387 child
.stdout_to_stderr
= 0;
1389 if (run_command(&child
))
1390 return "Working directory has staged changes";
1392 child_process_init(&child
);
1393 strvec_pushl(&child
.args
, "read-tree", "-u", "-m", hash_to_hex(sha1
),
1395 strvec_pushv(&child
.env
, env
->v
);
1396 child
.dir
= work_tree
;
1398 child
.no_stdout
= 1;
1399 child
.stdout_to_stderr
= 0;
1401 if (run_command(&child
))
1402 return "Could not update working tree to new HEAD";
1407 static const char *push_to_checkout_hook
= "push-to-checkout";
1409 static const char *push_to_checkout(unsigned char *hash
,
1412 const char *work_tree
)
1414 struct run_hooks_opt opt
= RUN_HOOKS_OPT_INIT
;
1415 opt
.invoked_hook
= invoked_hook
;
1417 strvec_pushf(env
, "GIT_WORK_TREE=%s", absolute_path(work_tree
));
1418 strvec_pushv(&opt
.env
, env
->v
);
1419 strvec_push(&opt
.args
, hash_to_hex(hash
));
1420 if (run_hooks_opt(push_to_checkout_hook
, &opt
))
1421 return "push-to-checkout hook declined";
1426 static const char *update_worktree(unsigned char *sha1
, const struct worktree
*worktree
)
1428 const char *retval
, *git_dir
;
1429 struct strvec env
= STRVEC_INIT
;
1432 if (!worktree
|| !worktree
->path
)
1433 BUG("worktree->path must be non-NULL");
1435 if (worktree
->is_bare
)
1436 return "denyCurrentBranch = updateInstead needs a worktree";
1437 git_dir
= get_worktree_git_dir(worktree
);
1439 strvec_pushf(&env
, "GIT_DIR=%s", absolute_path(git_dir
));
1441 retval
= push_to_checkout(sha1
, &invoked_hook
, &env
, worktree
->path
);
1443 retval
= push_to_deploy(sha1
, &env
, worktree
->path
);
1449 static const char *update(struct command
*cmd
, struct shallow_info
*si
)
1451 const char *name
= cmd
->ref_name
;
1452 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
1453 static char *namespaced_name
;
1455 struct object_id
*old_oid
= &cmd
->old_oid
;
1456 struct object_id
*new_oid
= &cmd
->new_oid
;
1457 int do_update_worktree
= 0;
1458 struct worktree
**worktrees
= get_worktrees();
1459 const struct worktree
*worktree
=
1460 find_shared_symref(worktrees
, "HEAD", name
);
1462 /* only refs/... are allowed */
1463 if (!starts_with(name
, "refs/") || check_refname_format(name
+ 5, 0)) {
1464 rp_error("refusing to create funny ref '%s' remotely", name
);
1465 ret
= "funny refname";
1469 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
1470 free(namespaced_name
);
1471 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
1473 if (worktree
&& !worktree
->is_bare
) {
1474 switch (deny_current_branch
) {
1478 rp_warning("updating the current branch");
1481 case DENY_UNCONFIGURED
:
1482 rp_error("refusing to update checked out branch: %s", name
);
1483 if (deny_current_branch
== DENY_UNCONFIGURED
)
1484 refuse_unconfigured_deny();
1485 ret
= "branch is currently checked out";
1487 case DENY_UPDATE_INSTEAD
:
1488 /* pass -- let other checks intervene first */
1489 do_update_worktree
= 1;
1494 if (!is_null_oid(new_oid
) && !has_object_file(new_oid
)) {
1495 error("unpack should have generated %s, "
1496 "but I can't find it!", oid_to_hex(new_oid
));
1501 if (!is_null_oid(old_oid
) && is_null_oid(new_oid
)) {
1502 if (deny_deletes
&& starts_with(name
, "refs/heads/")) {
1503 rp_error("denying ref deletion for %s", name
);
1504 ret
= "deletion prohibited";
1508 if (worktree
|| (head_name
&& !strcmp(namespaced_name
, head_name
))) {
1509 switch (deny_delete_current
) {
1513 rp_warning("deleting the current branch");
1516 case DENY_UNCONFIGURED
:
1517 case DENY_UPDATE_INSTEAD
:
1518 if (deny_delete_current
== DENY_UNCONFIGURED
)
1519 refuse_unconfigured_deny_delete_current();
1520 rp_error("refusing to delete the current branch: %s", name
);
1521 ret
= "deletion of the current branch prohibited";
1524 ret
= "Invalid denyDeleteCurrent setting";
1530 if (deny_non_fast_forwards
&& !is_null_oid(new_oid
) &&
1531 !is_null_oid(old_oid
) &&
1532 starts_with(name
, "refs/heads/")) {
1533 struct object
*old_object
, *new_object
;
1534 struct commit
*old_commit
, *new_commit
;
1536 old_object
= parse_object(the_repository
, old_oid
);
1537 new_object
= parse_object(the_repository
, new_oid
);
1539 if (!old_object
|| !new_object
||
1540 old_object
->type
!= OBJ_COMMIT
||
1541 new_object
->type
!= OBJ_COMMIT
) {
1542 error("bad sha1 objects for %s", name
);
1546 old_commit
= (struct commit
*)old_object
;
1547 new_commit
= (struct commit
*)new_object
;
1548 if (!in_merge_bases(old_commit
, new_commit
)) {
1549 rp_error("denying non-fast-forward %s"
1550 " (you should pull first)", name
);
1551 ret
= "non-fast-forward";
1555 if (run_update_hook(cmd
)) {
1556 rp_error("hook declined to update %s", name
);
1557 ret
= "hook declined";
1561 if (do_update_worktree
) {
1562 ret
= update_worktree(new_oid
->hash
, worktree
);
1567 if (is_null_oid(new_oid
)) {
1568 struct strbuf err
= STRBUF_INIT
;
1569 if (!parse_object(the_repository
, old_oid
)) {
1571 if (ref_exists(name
)) {
1572 rp_warning("allowing deletion of corrupt ref");
1574 rp_warning("deleting a non-existent ref");
1575 cmd
->did_not_exist
= 1;
1578 if (ref_transaction_delete(transaction
,
1582 rp_error("%s", err
.buf
);
1583 ret
= "failed to delete";
1585 ret
= NULL
; /* good */
1587 strbuf_release(&err
);
1590 struct strbuf err
= STRBUF_INIT
;
1591 if (shallow_update
&& si
->shallow_ref
[cmd
->index
] &&
1592 update_shallow_ref(cmd
, si
)) {
1593 ret
= "shallow error";
1597 if (ref_transaction_update(transaction
,
1602 rp_error("%s", err
.buf
);
1603 ret
= "failed to update ref";
1605 ret
= NULL
; /* good */
1607 strbuf_release(&err
);
1611 free_worktrees(worktrees
);
1615 static void run_update_post_hook(struct command
*commands
)
1617 struct command
*cmd
;
1618 struct child_process proc
= CHILD_PROCESS_INIT
;
1621 hook
= find_hook("post-update");
1625 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1626 if (cmd
->error_string
|| cmd
->did_not_exist
)
1629 strvec_push(&proc
.args
, hook
);
1630 strvec_push(&proc
.args
, cmd
->ref_name
);
1636 proc
.stdout_to_stderr
= 1;
1637 proc
.err
= use_sideband
? -1 : 0;
1638 proc
.trace2_hook_name
= "post-update";
1640 if (!start_command(&proc
)) {
1642 copy_to_sideband(proc
.err
, -1, NULL
);
1643 finish_command(&proc
);
1647 static void check_aliased_update_internal(struct command
*cmd
,
1648 struct string_list
*list
,
1649 const char *dst_name
, int flag
)
1651 struct string_list_item
*item
;
1652 struct command
*dst_cmd
;
1654 if (!(flag
& REF_ISSYMREF
))
1658 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
1659 cmd
->skip_update
= 1;
1660 cmd
->error_string
= "broken symref";
1663 dst_name
= strip_namespace(dst_name
);
1665 if (!(item
= string_list_lookup(list
, dst_name
)))
1668 cmd
->skip_update
= 1;
1670 dst_cmd
= (struct command
*) item
->util
;
1672 if (oideq(&cmd
->old_oid
, &dst_cmd
->old_oid
) &&
1673 oideq(&cmd
->new_oid
, &dst_cmd
->new_oid
))
1676 dst_cmd
->skip_update
= 1;
1678 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1679 " its target '%s' (%s..%s)",
1681 find_unique_abbrev(&cmd
->old_oid
, DEFAULT_ABBREV
),
1682 find_unique_abbrev(&cmd
->new_oid
, DEFAULT_ABBREV
),
1684 find_unique_abbrev(&dst_cmd
->old_oid
, DEFAULT_ABBREV
),
1685 find_unique_abbrev(&dst_cmd
->new_oid
, DEFAULT_ABBREV
));
1687 cmd
->error_string
= dst_cmd
->error_string
=
1688 "inconsistent aliased update";
1691 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
1693 struct strbuf buf
= STRBUF_INIT
;
1694 const char *dst_name
;
1697 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
1698 dst_name
= resolve_ref_unsafe(buf
.buf
, 0, NULL
, &flag
);
1699 check_aliased_update_internal(cmd
, list
, dst_name
, flag
);
1700 strbuf_release(&buf
);
1703 static void check_aliased_updates(struct command
*commands
)
1705 struct command
*cmd
;
1706 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
1708 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1709 struct string_list_item
*item
=
1710 string_list_append(&ref_list
, cmd
->ref_name
);
1711 item
->util
= (void *)cmd
;
1713 string_list_sort(&ref_list
);
1715 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1716 if (!cmd
->error_string
)
1717 check_aliased_update(cmd
, &ref_list
);
1720 string_list_clear(&ref_list
, 0);
1723 static const struct object_id
*command_singleton_iterator(void *cb_data
)
1725 struct command
**cmd_list
= cb_data
;
1726 struct command
*cmd
= *cmd_list
;
1728 if (!cmd
|| is_null_oid(&cmd
->new_oid
))
1730 *cmd_list
= NULL
; /* this returns only one */
1731 return &cmd
->new_oid
;
1734 static void set_connectivity_errors(struct command
*commands
,
1735 struct shallow_info
*si
)
1737 struct command
*cmd
;
1739 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1740 struct command
*singleton
= cmd
;
1741 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1743 if (shallow_update
&& si
->shallow_ref
[cmd
->index
])
1744 /* to be checked in update_shallow_ref() */
1747 opt
.env
= tmp_objdir_env(tmp_objdir
);
1748 if (!check_connected(command_singleton_iterator
, &singleton
,
1752 cmd
->error_string
= "missing necessary objects";
1756 struct iterate_data
{
1757 struct command
*cmds
;
1758 struct shallow_info
*si
;
1761 static const struct object_id
*iterate_receive_command_list(void *cb_data
)
1763 struct iterate_data
*data
= cb_data
;
1764 struct command
**cmd_list
= &data
->cmds
;
1765 struct command
*cmd
= *cmd_list
;
1767 for (; cmd
; cmd
= cmd
->next
) {
1768 if (shallow_update
&& data
->si
->shallow_ref
[cmd
->index
])
1769 /* to be checked in update_shallow_ref() */
1771 if (!is_null_oid(&cmd
->new_oid
) && !cmd
->skip_update
) {
1772 *cmd_list
= cmd
->next
;
1773 return &cmd
->new_oid
;
1779 static void reject_updates_to_hidden(struct command
*commands
)
1781 struct strbuf refname_full
= STRBUF_INIT
;
1783 struct command
*cmd
;
1785 strbuf_addstr(&refname_full
, get_git_namespace());
1786 prefix_len
= refname_full
.len
;
1788 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1789 if (cmd
->error_string
)
1792 strbuf_setlen(&refname_full
, prefix_len
);
1793 strbuf_addstr(&refname_full
, cmd
->ref_name
);
1795 if (!ref_is_hidden(cmd
->ref_name
, refname_full
.buf
, &hidden_refs
))
1797 if (is_null_oid(&cmd
->new_oid
))
1798 cmd
->error_string
= "deny deleting a hidden ref";
1800 cmd
->error_string
= "deny updating a hidden ref";
1803 strbuf_release(&refname_full
);
1806 static int should_process_cmd(struct command
*cmd
)
1808 return !cmd
->error_string
&& !cmd
->skip_update
;
1811 static void BUG_if_skipped_connectivity_check(struct command
*commands
,
1812 struct shallow_info
*si
)
1814 struct command
*cmd
;
1816 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1817 if (should_process_cmd(cmd
) && si
->shallow_ref
[cmd
->index
])
1818 bug("connectivity check has not been run on ref %s",
1821 BUG_if_bug("connectivity check skipped???");
1824 static void execute_commands_non_atomic(struct command
*commands
,
1825 struct shallow_info
*si
)
1827 struct command
*cmd
;
1828 struct strbuf err
= STRBUF_INIT
;
1830 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1831 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1834 transaction
= ref_transaction_begin(&err
);
1836 rp_error("%s", err
.buf
);
1838 cmd
->error_string
= "transaction failed to start";
1842 cmd
->error_string
= update(cmd
, si
);
1844 if (!cmd
->error_string
1845 && ref_transaction_commit(transaction
, &err
)) {
1846 rp_error("%s", err
.buf
);
1848 cmd
->error_string
= "failed to update ref";
1850 ref_transaction_free(transaction
);
1852 strbuf_release(&err
);
1855 static void execute_commands_atomic(struct command
*commands
,
1856 struct shallow_info
*si
)
1858 struct command
*cmd
;
1859 struct strbuf err
= STRBUF_INIT
;
1860 const char *reported_error
= "atomic push failure";
1862 transaction
= ref_transaction_begin(&err
);
1864 rp_error("%s", err
.buf
);
1866 reported_error
= "transaction failed to start";
1870 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1871 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1874 cmd
->error_string
= update(cmd
, si
);
1876 if (cmd
->error_string
)
1880 if (ref_transaction_commit(transaction
, &err
)) {
1881 rp_error("%s", err
.buf
);
1882 reported_error
= "atomic transaction failed";
1888 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1889 if (!cmd
->error_string
)
1890 cmd
->error_string
= reported_error
;
1893 ref_transaction_free(transaction
);
1894 strbuf_release(&err
);
1897 static void execute_commands(struct command
*commands
,
1898 const char *unpacker_error
,
1899 struct shallow_info
*si
,
1900 const struct string_list
*push_options
)
1902 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1903 struct command
*cmd
;
1904 struct iterate_data data
;
1907 int run_proc_receive
= 0;
1909 if (unpacker_error
) {
1910 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1911 cmd
->error_string
= "unpacker error";
1916 memset(&muxer
, 0, sizeof(muxer
));
1917 muxer
.proc
= copy_to_sideband
;
1919 if (!start_async(&muxer
))
1921 /* ...else, continue without relaying sideband */
1924 data
.cmds
= commands
;
1926 opt
.err_fd
= err_fd
;
1927 opt
.progress
= err_fd
&& !quiet
;
1928 opt
.env
= tmp_objdir_env(tmp_objdir
);
1929 opt
.exclude_hidden_refs_section
= "receive";
1931 if (check_connected(iterate_receive_command_list
, &data
, &opt
))
1932 set_connectivity_errors(commands
, si
);
1935 finish_async(&muxer
);
1937 reject_updates_to_hidden(commands
);
1940 * Try to find commands that have special prefix in their reference names,
1941 * and mark them to run an external "proc-receive" hook later.
1943 if (proc_receive_ref
) {
1944 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1945 if (!should_process_cmd(cmd
))
1948 if (proc_receive_ref_matches(cmd
)) {
1949 cmd
->run_proc_receive
= RUN_PROC_RECEIVE_SCHEDULED
;
1950 run_proc_receive
= 1;
1955 if (run_receive_hook(commands
, "pre-receive", 0, push_options
)) {
1956 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1957 if (!cmd
->error_string
)
1958 cmd
->error_string
= "pre-receive hook declined";
1964 * If there is no command ready to run, should return directly to destroy
1965 * temporary data in the quarantine area.
1967 for (cmd
= commands
; cmd
&& cmd
->error_string
; cmd
= cmd
->next
)
1973 * Now we'll start writing out refs, which means the objects need
1974 * to be in their final positions so that other processes can see them.
1976 if (tmp_objdir_migrate(tmp_objdir
) < 0) {
1977 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1978 if (!cmd
->error_string
)
1979 cmd
->error_string
= "unable to migrate objects to permanent storage";
1985 check_aliased_updates(commands
);
1987 free(head_name_to_free
);
1988 head_name
= head_name_to_free
= resolve_refdup("HEAD", 0, NULL
, NULL
);
1990 if (run_proc_receive
&&
1991 run_proc_receive_hook(commands
, push_options
))
1992 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1993 if (!cmd
->error_string
&&
1994 !(cmd
->run_proc_receive
& RUN_PROC_RECEIVE_RETURNED
) &&
1995 (cmd
->run_proc_receive
|| use_atomic
))
1996 cmd
->error_string
= "fail to run proc-receive hook";
1999 execute_commands_atomic(commands
, si
);
2001 execute_commands_non_atomic(commands
, si
);
2004 BUG_if_skipped_connectivity_check(commands
, si
);
2007 static struct command
**queue_command(struct command
**tail
,
2011 struct object_id old_oid
, new_oid
;
2012 struct command
*cmd
;
2013 const char *refname
;
2017 if (parse_oid_hex(line
, &old_oid
, &p
) ||
2019 parse_oid_hex(p
, &new_oid
, &p
) ||
2021 die("protocol error: expected old/new/ref, got '%s'", line
);
2024 reflen
= linelen
- (p
- line
);
2025 FLEX_ALLOC_MEM(cmd
, ref_name
, refname
, reflen
);
2026 oidcpy(&cmd
->old_oid
, &old_oid
);
2027 oidcpy(&cmd
->new_oid
, &new_oid
);
2032 static void free_commands(struct command
*commands
)
2035 struct command
*next
= commands
->next
;
2042 static void queue_commands_from_cert(struct command
**tail
,
2043 struct strbuf
*push_cert
)
2045 const char *boc
, *eoc
;
2048 die("protocol error: got both push certificate and unsigned commands");
2050 boc
= strstr(push_cert
->buf
, "\n\n");
2052 die("malformed push certificate %.*s", 100, push_cert
->buf
);
2055 eoc
= push_cert
->buf
+ parse_signed_buffer(push_cert
->buf
, push_cert
->len
);
2058 const char *eol
= memchr(boc
, '\n', eoc
- boc
);
2059 tail
= queue_command(tail
, boc
, eol
? eol
- boc
: eoc
- boc
);
2060 boc
= eol
? eol
+ 1 : eoc
;
2064 static struct command
*read_head_info(struct packet_reader
*reader
,
2065 struct oid_array
*shallow
)
2067 struct command
*commands
= NULL
;
2068 struct command
**p
= &commands
;
2072 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
2075 if (reader
->pktlen
> 8 && starts_with(reader
->line
, "shallow ")) {
2076 struct object_id oid
;
2077 if (get_oid_hex(reader
->line
+ 8, &oid
))
2078 die("protocol error: expected shallow sha, got '%s'",
2080 oid_array_append(shallow
, &oid
);
2084 linelen
= strlen(reader
->line
);
2085 if (linelen
< reader
->pktlen
) {
2086 const char *feature_list
= reader
->line
+ linelen
+ 1;
2087 const char *hash
= NULL
;
2088 const char *client_sid
;
2090 if (parse_feature_request(feature_list
, "report-status"))
2092 if (parse_feature_request(feature_list
, "report-status-v2"))
2093 report_status_v2
= 1;
2094 if (parse_feature_request(feature_list
, "side-band-64k"))
2095 use_sideband
= LARGE_PACKET_MAX
;
2096 if (parse_feature_request(feature_list
, "quiet"))
2098 if (advertise_atomic_push
2099 && parse_feature_request(feature_list
, "atomic"))
2101 if (advertise_push_options
2102 && parse_feature_request(feature_list
, "push-options"))
2103 use_push_options
= 1;
2104 hash
= parse_feature_value(feature_list
, "object-format", &len
, NULL
);
2106 hash
= hash_algos
[GIT_HASH_SHA1
].name
;
2109 if (xstrncmpz(the_hash_algo
->name
, hash
, len
))
2110 die("error: unsupported object format '%s'", hash
);
2111 client_sid
= parse_feature_value(feature_list
, "session-id", &len
, NULL
);
2113 char *sid
= xstrndup(client_sid
, len
);
2114 trace2_data_string("transfer", NULL
, "client-sid", client_sid
);
2119 if (!strcmp(reader
->line
, "push-cert")) {
2121 int saved_options
= reader
->options
;
2122 reader
->options
&= ~PACKET_READ_CHOMP_NEWLINE
;
2125 packet_reader_read(reader
);
2126 if (reader
->status
== PACKET_READ_FLUSH
) {
2130 if (reader
->status
!= PACKET_READ_NORMAL
) {
2131 die("protocol error: got an unexpected packet");
2133 if (!strcmp(reader
->line
, "push-cert-end\n"))
2134 break; /* end of cert */
2135 strbuf_addstr(&push_cert
, reader
->line
);
2137 reader
->options
= saved_options
;
2144 p
= queue_command(p
, reader
->line
, linelen
);
2148 queue_commands_from_cert(p
, &push_cert
);
2153 static void read_push_options(struct packet_reader
*reader
,
2154 struct string_list
*options
)
2157 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
2160 string_list_append(options
, reader
->line
);
2164 static const char *parse_pack_header(struct pack_header
*hdr
)
2166 switch (read_pack_header(0, hdr
)) {
2168 return "eof before pack header was fully read";
2170 case PH_ERROR_PACK_SIGNATURE
:
2171 return "protocol error (pack signature mismatch detected)";
2173 case PH_ERROR_PROTOCOL
:
2174 return "protocol error (pack version unsupported)";
2177 return "unknown error in parse_pack_header";
2184 static const char *pack_lockfile
;
2186 static void push_header_arg(struct strvec
*args
, struct pack_header
*hdr
)
2188 strvec_pushf(args
, "--pack_header=%"PRIu32
",%"PRIu32
,
2189 ntohl(hdr
->hdr_version
), ntohl(hdr
->hdr_entries
));
2192 static const char *unpack(int err_fd
, struct shallow_info
*si
)
2194 struct pack_header hdr
;
2195 const char *hdr_err
;
2197 struct child_process child
= CHILD_PROCESS_INIT
;
2198 int fsck_objects
= (receive_fsck_objects
>= 0
2199 ? receive_fsck_objects
2200 : transfer_fsck_objects
>= 0
2201 ? transfer_fsck_objects
2204 hdr_err
= parse_pack_header(&hdr
);
2211 if (si
->nr_ours
|| si
->nr_theirs
) {
2212 alt_shallow_file
= setup_temporary_shallow(si
->shallow
);
2213 strvec_push(&child
.args
, "--shallow-file");
2214 strvec_push(&child
.args
, alt_shallow_file
);
2217 tmp_objdir
= tmp_objdir_create("incoming");
2221 return "unable to create temporary object directory";
2223 strvec_pushv(&child
.env
, tmp_objdir_env(tmp_objdir
));
2226 * Normally we just pass the tmp_objdir environment to the child
2227 * processes that do the heavy lifting, but we may need to see these
2228 * objects ourselves to set up shallow information.
2230 tmp_objdir_add_as_alternate(tmp_objdir
);
2232 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
2233 strvec_push(&child
.args
, "unpack-objects");
2234 push_header_arg(&child
.args
, &hdr
);
2236 strvec_push(&child
.args
, "-q");
2238 strvec_pushf(&child
.args
, "--strict%s",
2239 fsck_msg_types
.buf
);
2241 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2242 (uintmax_t)max_input_size
);
2243 child
.no_stdout
= 1;
2246 status
= run_command(&child
);
2248 return "unpack-objects abnormal exit";
2250 char hostname
[HOST_NAME_MAX
+ 1];
2252 strvec_pushl(&child
.args
, "index-pack", "--stdin", NULL
);
2253 push_header_arg(&child
.args
, &hdr
);
2255 if (xgethostname(hostname
, sizeof(hostname
)))
2256 xsnprintf(hostname
, sizeof(hostname
), "localhost");
2257 strvec_pushf(&child
.args
,
2258 "--keep=receive-pack %"PRIuMAX
" on %s",
2259 (uintmax_t)getpid(),
2262 if (!quiet
&& err_fd
)
2263 strvec_push(&child
.args
, "--show-resolving-progress");
2265 strvec_push(&child
.args
, "--report-end-of-input");
2267 strvec_pushf(&child
.args
, "--strict%s",
2268 fsck_msg_types
.buf
);
2270 strvec_push(&child
.args
, "--fix-thin");
2272 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2273 (uintmax_t)max_input_size
);
2277 status
= start_command(&child
);
2279 return "index-pack fork failed";
2280 pack_lockfile
= index_pack_lockfile(child
.out
, NULL
);
2282 status
= finish_command(&child
);
2284 return "index-pack abnormal exit";
2285 reprepare_packed_git(the_repository
);
2290 static const char *unpack_with_sideband(struct shallow_info
*si
)
2296 return unpack(0, si
);
2298 use_keepalive
= KEEPALIVE_AFTER_NUL
;
2299 memset(&muxer
, 0, sizeof(muxer
));
2300 muxer
.proc
= copy_to_sideband
;
2302 if (start_async(&muxer
))
2305 ret
= unpack(muxer
.in
, si
);
2307 finish_async(&muxer
);
2311 static void prepare_shallow_update(struct shallow_info
*si
)
2313 int i
, j
, k
, bitmap_size
= DIV_ROUND_UP(si
->ref
->nr
, 32);
2315 ALLOC_ARRAY(si
->used_shallow
, si
->shallow
->nr
);
2316 assign_shallow_commits_to_refs(si
, si
->used_shallow
, NULL
);
2318 CALLOC_ARRAY(si
->need_reachability_test
, si
->shallow
->nr
);
2319 CALLOC_ARRAY(si
->reachable
, si
->shallow
->nr
);
2320 CALLOC_ARRAY(si
->shallow_ref
, si
->ref
->nr
);
2322 for (i
= 0; i
< si
->nr_ours
; i
++)
2323 si
->need_reachability_test
[si
->ours
[i
]] = 1;
2325 for (i
= 0; i
< si
->shallow
->nr
; i
++) {
2326 if (!si
->used_shallow
[i
])
2328 for (j
= 0; j
< bitmap_size
; j
++) {
2329 if (!si
->used_shallow
[i
][j
])
2331 si
->need_reachability_test
[i
]++;
2332 for (k
= 0; k
< 32; k
++)
2333 if (si
->used_shallow
[i
][j
] & (1U << k
))
2334 si
->shallow_ref
[j
* 32 + k
]++;
2338 * true for those associated with some refs and belong
2339 * in "ours" list aka "step 7 not done yet"
2341 si
->need_reachability_test
[i
] =
2342 si
->need_reachability_test
[i
] > 1;
2346 * keep hooks happy by forcing a temporary shallow file via
2347 * env variable because we can't add --shallow-file to every
2348 * command. check_connected() will be done with
2349 * true .git/shallow though.
2351 setenv(GIT_SHALLOW_FILE_ENVIRONMENT
, alt_shallow_file
, 1);
2354 static void update_shallow_info(struct command
*commands
,
2355 struct shallow_info
*si
,
2356 struct oid_array
*ref
)
2358 struct command
*cmd
;
2360 remove_nonexistent_theirs_shallow(si
);
2361 if (!si
->nr_ours
&& !si
->nr_theirs
) {
2366 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2367 if (is_null_oid(&cmd
->new_oid
))
2369 oid_array_append(ref
, &cmd
->new_oid
);
2370 cmd
->index
= ref
->nr
- 1;
2374 if (shallow_update
) {
2375 prepare_shallow_update(si
);
2379 ALLOC_ARRAY(ref_status
, ref
->nr
);
2380 assign_shallow_commits_to_refs(si
, NULL
, ref_status
);
2381 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2382 if (is_null_oid(&cmd
->new_oid
))
2384 if (ref_status
[cmd
->index
]) {
2385 cmd
->error_string
= "shallow update not allowed";
2386 cmd
->skip_update
= 1;
2392 static void report(struct command
*commands
, const char *unpack_status
)
2394 struct command
*cmd
;
2395 struct strbuf buf
= STRBUF_INIT
;
2397 packet_buf_write(&buf
, "unpack %s\n",
2398 unpack_status
? unpack_status
: "ok");
2399 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2400 if (!cmd
->error_string
)
2401 packet_buf_write(&buf
, "ok %s\n",
2404 packet_buf_write(&buf
, "ng %s %s\n",
2405 cmd
->ref_name
, cmd
->error_string
);
2407 packet_buf_flush(&buf
);
2410 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2412 write_or_die(1, buf
.buf
, buf
.len
);
2413 strbuf_release(&buf
);
2416 static void report_v2(struct command
*commands
, const char *unpack_status
)
2418 struct command
*cmd
;
2419 struct strbuf buf
= STRBUF_INIT
;
2420 struct ref_push_report
*report
;
2422 packet_buf_write(&buf
, "unpack %s\n",
2423 unpack_status
? unpack_status
: "ok");
2424 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2427 if (cmd
->error_string
) {
2428 packet_buf_write(&buf
, "ng %s %s\n",
2433 packet_buf_write(&buf
, "ok %s\n",
2435 for (report
= cmd
->report
; report
; report
= report
->next
) {
2437 packet_buf_write(&buf
, "ok %s\n",
2439 if (report
->ref_name
)
2440 packet_buf_write(&buf
, "option refname %s\n",
2442 if (report
->old_oid
)
2443 packet_buf_write(&buf
, "option old-oid %s\n",
2444 oid_to_hex(report
->old_oid
));
2445 if (report
->new_oid
)
2446 packet_buf_write(&buf
, "option new-oid %s\n",
2447 oid_to_hex(report
->new_oid
));
2448 if (report
->forced_update
)
2449 packet_buf_write(&buf
, "option forced-update\n");
2452 packet_buf_flush(&buf
);
2455 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2457 write_or_die(1, buf
.buf
, buf
.len
);
2458 strbuf_release(&buf
);
2461 static int delete_only(struct command
*commands
)
2463 struct command
*cmd
;
2464 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2465 if (!is_null_oid(&cmd
->new_oid
))
2471 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
2473 int advertise_refs
= 0;
2474 struct command
*commands
;
2475 struct oid_array shallow
= OID_ARRAY_INIT
;
2476 struct oid_array ref
= OID_ARRAY_INIT
;
2477 struct shallow_info si
;
2478 struct packet_reader reader
;
2480 struct option options
[] = {
2481 OPT__QUIET(&quiet
, N_("quiet")),
2482 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc
, NULL
),
2483 OPT_HIDDEN_BOOL(0, "http-backend-info-refs", &advertise_refs
, NULL
),
2484 OPT_ALIAS(0, "advertise-refs", "http-backend-info-refs"),
2485 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin
, NULL
),
2489 packet_trace_identity("receive-pack");
2491 argc
= parse_options(argc
, argv
, prefix
, options
, receive_pack_usage
, 0);
2494 usage_msg_opt(_("too many arguments"), receive_pack_usage
, options
);
2496 usage_msg_opt(_("you must specify a directory"), receive_pack_usage
, options
);
2498 service_dir
= argv
[0];
2502 if (!enter_repo(service_dir
, 0))
2503 die("'%s' does not appear to be a git repository", service_dir
);
2505 git_config(receive_pack_config
, NULL
);
2506 if (cert_nonce_seed
)
2507 push_cert_nonce
= prepare_push_cert_nonce(service_dir
, time(NULL
));
2509 if (0 <= transfer_unpack_limit
)
2510 unpack_limit
= transfer_unpack_limit
;
2511 else if (0 <= receive_unpack_limit
)
2512 unpack_limit
= receive_unpack_limit
;
2514 switch (determine_protocol_version_server()) {
2517 * push support for protocol v2 has not been implemented yet,
2518 * so ignore the request to use v2 and fallback to using v0.
2523 * v1 is just the original protocol with a version string,
2524 * so just fall through after writing the version string.
2526 if (advertise_refs
|| !stateless_rpc
)
2527 packet_write_fmt(1, "version 1\n");
2532 case protocol_unknown_version
:
2533 BUG("unknown protocol version");
2536 if (advertise_refs
|| !stateless_rpc
) {
2542 packet_reader_init(&reader
, 0, NULL
, 0,
2543 PACKET_READ_CHOMP_NEWLINE
|
2544 PACKET_READ_DIE_ON_ERR_PACKET
);
2546 if ((commands
= read_head_info(&reader
, &shallow
))) {
2547 const char *unpack_status
= NULL
;
2548 struct string_list push_options
= STRING_LIST_INIT_DUP
;
2550 if (use_push_options
)
2551 read_push_options(&reader
, &push_options
);
2552 if (!check_cert_push_options(&push_options
)) {
2553 struct command
*cmd
;
2554 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
2555 cmd
->error_string
= "inconsistent push options";
2558 prepare_shallow_info(&si
, &shallow
);
2559 if (!si
.nr_ours
&& !si
.nr_theirs
)
2561 if (!delete_only(commands
)) {
2562 unpack_status
= unpack_with_sideband(&si
);
2563 update_shallow_info(commands
, &si
, &ref
);
2565 use_keepalive
= KEEPALIVE_ALWAYS
;
2566 execute_commands(commands
, unpack_status
, &si
,
2569 unlink_or_warn(pack_lockfile
);
2570 sigchain_push(SIGPIPE
, SIG_IGN
);
2571 if (report_status_v2
)
2572 report_v2(commands
, unpack_status
);
2573 else if (report_status
)
2574 report(commands
, unpack_status
);
2575 sigchain_pop(SIGPIPE
);
2576 run_receive_hook(commands
, "post-receive", 1,
2578 run_update_post_hook(commands
);
2579 free_commands(commands
);
2580 string_list_clear(&push_options
, 0);
2582 struct child_process proc
= CHILD_PROCESS_INIT
;
2585 proc
.stdout_to_stderr
= 1;
2586 proc
.err
= use_sideband
? -1 : 0;
2587 proc
.git_cmd
= proc
.close_object_store
= 1;
2588 strvec_pushl(&proc
.args
, "gc", "--auto", "--quiet",
2591 if (!start_command(&proc
)) {
2593 copy_to_sideband(proc
.err
, -1, NULL
);
2594 finish_command(&proc
);
2597 if (auto_update_server_info
)
2598 update_server_info(0);
2599 clear_shallow_info(&si
);
2603 oid_array_clear(&shallow
);
2604 oid_array_clear(&ref
);
2605 string_list_clear(&hidden_refs
, 0);
2606 free((void *)push_cert_nonce
);