2 #include "repository.h"
9 #include "run-command.h"
16 #include "string-list.h"
17 #include "oid-array.h"
18 #include "connected.h"
22 #include "gpg-interface.h"
25 #include "tmp-objdir.h"
28 #include "object-store.h"
30 #include "commit-reach.h"
34 static const char * const receive_pack_usage
[] = {
35 N_("git receive-pack <git-dir>"),
47 static int deny_deletes
;
48 static int deny_non_fast_forwards
;
49 static enum deny_action deny_current_branch
= DENY_UNCONFIGURED
;
50 static enum deny_action deny_delete_current
= DENY_UNCONFIGURED
;
51 static int receive_fsck_objects
= -1;
52 static int transfer_fsck_objects
= -1;
53 static struct strbuf fsck_msg_types
= STRBUF_INIT
;
54 static int receive_unpack_limit
= -1;
55 static int transfer_unpack_limit
= -1;
56 static int advertise_atomic_push
= 1;
57 static int advertise_push_options
;
58 static int advertise_sid
;
59 static int unpack_limit
= 100;
60 static off_t max_input_size
;
61 static int report_status
;
62 static int report_status_v2
;
63 static int use_sideband
;
64 static int use_atomic
;
65 static int use_push_options
;
67 static int prefer_ofs_delta
= 1;
68 static int auto_update_server_info
;
69 static int auto_gc
= 1;
70 static int reject_thin
;
71 static int stateless_rpc
;
72 static const char *service_dir
;
73 static const char *head_name
;
74 static void *head_name_to_free
;
75 static int sent_capabilities
;
76 static int shallow_update
;
77 static const char *alt_shallow_file
;
78 static struct strbuf push_cert
= STRBUF_INIT
;
79 static struct object_id push_cert_oid
;
80 static struct signature_check sigcheck
;
81 static const char *push_cert_nonce
;
82 static const char *cert_nonce_seed
;
84 static const char *NONCE_UNSOLICITED
= "UNSOLICITED";
85 static const char *NONCE_BAD
= "BAD";
86 static const char *NONCE_MISSING
= "MISSING";
87 static const char *NONCE_OK
= "OK";
88 static const char *NONCE_SLOP
= "SLOP";
89 static const char *nonce_status
;
90 static long nonce_stamp_slop
;
91 static timestamp_t nonce_stamp_slop_limit
;
92 static struct ref_transaction
*transaction
;
99 static int keepalive_in_sec
= 5;
101 static struct tmp_objdir
*tmp_objdir
;
103 static struct proc_receive_ref
{
104 unsigned int want_add
:1,
109 struct proc_receive_ref
*next
;
112 static void proc_receive_ref_append(const char *prefix
);
114 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
117 if (!strcasecmp(value
, "ignore"))
119 if (!strcasecmp(value
, "warn"))
121 if (!strcasecmp(value
, "refuse"))
123 if (!strcasecmp(value
, "updateinstead"))
124 return DENY_UPDATE_INSTEAD
;
126 if (git_config_bool(var
, value
))
131 static int receive_pack_config(const char *var
, const char *value
, void *cb
)
133 int status
= parse_hide_refs_config(var
, value
, "receive");
138 status
= git_gpg_config(var
, value
, NULL
);
142 if (strcmp(var
, "receive.denydeletes") == 0) {
143 deny_deletes
= git_config_bool(var
, value
);
147 if (strcmp(var
, "receive.denynonfastforwards") == 0) {
148 deny_non_fast_forwards
= git_config_bool(var
, value
);
152 if (strcmp(var
, "receive.unpacklimit") == 0) {
153 receive_unpack_limit
= git_config_int(var
, value
);
157 if (strcmp(var
, "transfer.unpacklimit") == 0) {
158 transfer_unpack_limit
= git_config_int(var
, value
);
162 if (strcmp(var
, "receive.fsck.skiplist") == 0) {
165 if (git_config_pathname(&path
, var
, value
))
167 strbuf_addf(&fsck_msg_types
, "%cskiplist=%s",
168 fsck_msg_types
.len
? ',' : '=', path
);
173 if (skip_prefix(var
, "receive.fsck.", &var
)) {
174 if (is_valid_msg_type(var
, value
))
175 strbuf_addf(&fsck_msg_types
, "%c%s=%s",
176 fsck_msg_types
.len
? ',' : '=', var
, value
);
178 warning("skipping unknown msg id '%s'", var
);
182 if (strcmp(var
, "receive.fsckobjects") == 0) {
183 receive_fsck_objects
= git_config_bool(var
, value
);
187 if (strcmp(var
, "transfer.fsckobjects") == 0) {
188 transfer_fsck_objects
= git_config_bool(var
, value
);
192 if (!strcmp(var
, "receive.denycurrentbranch")) {
193 deny_current_branch
= parse_deny_action(var
, value
);
197 if (strcmp(var
, "receive.denydeletecurrent") == 0) {
198 deny_delete_current
= parse_deny_action(var
, value
);
202 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
203 prefer_ofs_delta
= git_config_bool(var
, value
);
207 if (strcmp(var
, "receive.updateserverinfo") == 0) {
208 auto_update_server_info
= git_config_bool(var
, value
);
212 if (strcmp(var
, "receive.autogc") == 0) {
213 auto_gc
= git_config_bool(var
, value
);
217 if (strcmp(var
, "receive.shallowupdate") == 0) {
218 shallow_update
= git_config_bool(var
, value
);
222 if (strcmp(var
, "receive.certnonceseed") == 0)
223 return git_config_string(&cert_nonce_seed
, var
, value
);
225 if (strcmp(var
, "receive.certnonceslop") == 0) {
226 nonce_stamp_slop_limit
= git_config_ulong(var
, value
);
230 if (strcmp(var
, "receive.advertiseatomic") == 0) {
231 advertise_atomic_push
= git_config_bool(var
, value
);
235 if (strcmp(var
, "receive.advertisepushoptions") == 0) {
236 advertise_push_options
= git_config_bool(var
, value
);
240 if (strcmp(var
, "receive.keepalive") == 0) {
241 keepalive_in_sec
= git_config_int(var
, value
);
245 if (strcmp(var
, "receive.maxinputsize") == 0) {
246 max_input_size
= git_config_int64(var
, value
);
250 if (strcmp(var
, "receive.procreceiverefs") == 0) {
252 return config_error_nonbool(var
);
253 proc_receive_ref_append(value
);
257 if (strcmp(var
, "transfer.advertisesid") == 0) {
258 advertise_sid
= git_config_bool(var
, value
);
262 return git_default_config(var
, value
, cb
);
265 static void show_ref(const char *path
, const struct object_id
*oid
)
267 if (sent_capabilities
) {
268 packet_write_fmt(1, "%s %s\n", oid_to_hex(oid
), path
);
270 struct strbuf cap
= STRBUF_INIT
;
273 "report-status report-status-v2 delete-refs side-band-64k quiet");
274 if (advertise_atomic_push
)
275 strbuf_addstr(&cap
, " atomic");
276 if (prefer_ofs_delta
)
277 strbuf_addstr(&cap
, " ofs-delta");
279 strbuf_addf(&cap
, " push-cert=%s", push_cert_nonce
);
280 if (advertise_push_options
)
281 strbuf_addstr(&cap
, " push-options");
283 strbuf_addf(&cap
, " session-id=%s", trace2_session_id());
284 strbuf_addf(&cap
, " object-format=%s", the_hash_algo
->name
);
285 strbuf_addf(&cap
, " agent=%s", git_user_agent_sanitized());
286 packet_write_fmt(1, "%s %s%c%s\n",
287 oid_to_hex(oid
), path
, 0, cap
.buf
);
288 strbuf_release(&cap
);
289 sent_capabilities
= 1;
293 static int show_ref_cb(const char *path_full
, const struct object_id
*oid
,
294 int flag
, void *data
)
296 struct oidset
*seen
= data
;
297 const char *path
= strip_namespace(path_full
);
299 if (ref_is_hidden(path
, path_full
))
303 * Advertise refs outside our current namespace as ".have"
304 * refs, so that the client can use them to minimize data
305 * transfer but will otherwise ignore them.
308 if (oidset_insert(seen
, oid
))
312 oidset_insert(seen
, oid
);
318 static void show_one_alternate_ref(const struct object_id
*oid
,
321 struct oidset
*seen
= data
;
323 if (oidset_insert(seen
, oid
))
326 show_ref(".have", oid
);
329 static void write_head_info(void)
331 static struct oidset seen
= OIDSET_INIT
;
333 for_each_ref(show_ref_cb
, &seen
);
334 for_each_alternate_ref(show_one_alternate_ref
, &seen
);
336 if (!sent_capabilities
)
337 show_ref("capabilities^{}", null_oid());
339 advertise_shallow_grafts(1);
345 #define RUN_PROC_RECEIVE_SCHEDULED 1
346 #define RUN_PROC_RECEIVE_RETURNED 2
348 struct command
*next
;
349 const char *error_string
;
350 struct ref_push_report
*report
;
351 unsigned int skip_update
:1,
355 struct object_id old_oid
;
356 struct object_id new_oid
;
357 char ref_name
[FLEX_ARRAY
]; /* more */
360 static void proc_receive_ref_append(const char *prefix
)
362 struct proc_receive_ref
*ref_pattern
;
366 CALLOC_ARRAY(ref_pattern
, 1);
367 p
= strchr(prefix
, ':');
371 ref_pattern
->want_add
= 1;
372 else if (*prefix
== 'd')
373 ref_pattern
->want_delete
= 1;
374 else if (*prefix
== 'm')
375 ref_pattern
->want_modify
= 1;
376 else if (*prefix
== '!')
377 ref_pattern
->negative_ref
= 1;
382 ref_pattern
->want_add
= 1;
383 ref_pattern
->want_delete
= 1;
384 ref_pattern
->want_modify
= 1;
386 len
= strlen(prefix
);
387 while (len
&& prefix
[len
- 1] == '/')
389 ref_pattern
->ref_prefix
= xmemdupz(prefix
, len
);
390 if (!proc_receive_ref
) {
391 proc_receive_ref
= ref_pattern
;
393 struct proc_receive_ref
*end
;
395 end
= proc_receive_ref
;
398 end
->next
= ref_pattern
;
402 static int proc_receive_ref_matches(struct command
*cmd
)
404 struct proc_receive_ref
*p
;
406 if (!proc_receive_ref
)
409 for (p
= proc_receive_ref
; p
; p
= p
->next
) {
410 const char *match
= p
->ref_prefix
;
413 if (!p
->want_add
&& is_null_oid(&cmd
->old_oid
))
415 else if (!p
->want_delete
&& is_null_oid(&cmd
->new_oid
))
417 else if (!p
->want_modify
&&
418 !is_null_oid(&cmd
->old_oid
) &&
419 !is_null_oid(&cmd
->new_oid
))
422 if (skip_prefix(cmd
->ref_name
, match
, &remains
) &&
423 (!*remains
|| *remains
== '/')) {
424 if (!p
->negative_ref
)
426 } else if (p
->negative_ref
) {
433 static void report_message(const char *prefix
, const char *err
, va_list params
)
438 sz
= xsnprintf(msg
, sizeof(msg
), "%s", prefix
);
439 sz
+= vsnprintf(msg
+ sz
, sizeof(msg
) - sz
, err
, params
);
440 if (sz
> (sizeof(msg
) - 1))
441 sz
= sizeof(msg
) - 1;
445 send_sideband(1, 2, msg
, sz
, use_sideband
);
450 __attribute__((format (printf
, 1, 2)))
451 static void rp_warning(const char *err
, ...)
454 va_start(params
, err
);
455 report_message("warning: ", err
, params
);
459 __attribute__((format (printf
, 1, 2)))
460 static void rp_error(const char *err
, ...)
463 va_start(params
, err
);
464 report_message("error: ", err
, params
);
468 static int copy_to_sideband(int in
, int out
, void *arg
)
471 int keepalive_active
= 0;
473 if (keepalive_in_sec
<= 0)
474 use_keepalive
= KEEPALIVE_NEVER
;
475 if (use_keepalive
== KEEPALIVE_ALWAYS
)
476 keepalive_active
= 1;
481 if (keepalive_active
) {
487 ret
= poll(&pfd
, 1, 1000 * keepalive_in_sec
);
494 } else if (ret
== 0) {
495 /* no data; send a keepalive packet */
496 static const char buf
[] = "0005\1";
497 write_or_die(1, buf
, sizeof(buf
) - 1);
499 } /* else there is actual data to read */
502 sz
= xread(in
, data
, sizeof(data
));
506 if (use_keepalive
== KEEPALIVE_AFTER_NUL
&& !keepalive_active
) {
507 const char *p
= memchr(data
, '\0', sz
);
510 * The NUL tells us to start sending keepalives. Make
511 * sure we send any other data we read along
514 keepalive_active
= 1;
515 send_sideband(1, 2, data
, p
- data
, use_sideband
);
516 send_sideband(1, 2, p
+ 1, sz
- (p
- data
+ 1), use_sideband
);
522 * Either we're not looking for a NUL signal, or we didn't see
523 * it yet; just pass along the data.
525 send_sideband(1, 2, data
, sz
, use_sideband
);
531 static void hmac_hash(unsigned char *out
,
532 const char *key_in
, size_t key_len
,
533 const char *text
, size_t text_len
)
535 unsigned char key
[GIT_MAX_BLKSZ
];
536 unsigned char k_ipad
[GIT_MAX_BLKSZ
];
537 unsigned char k_opad
[GIT_MAX_BLKSZ
];
541 /* RFC 2104 2. (1) */
542 memset(key
, '\0', GIT_MAX_BLKSZ
);
543 if (the_hash_algo
->blksz
< key_len
) {
544 the_hash_algo
->init_fn(&ctx
);
545 the_hash_algo
->update_fn(&ctx
, key_in
, key_len
);
546 the_hash_algo
->final_fn(key
, &ctx
);
548 memcpy(key
, key_in
, key_len
);
551 /* RFC 2104 2. (2) & (5) */
552 for (i
= 0; i
< sizeof(key
); i
++) {
553 k_ipad
[i
] = key
[i
] ^ 0x36;
554 k_opad
[i
] = key
[i
] ^ 0x5c;
557 /* RFC 2104 2. (3) & (4) */
558 the_hash_algo
->init_fn(&ctx
);
559 the_hash_algo
->update_fn(&ctx
, k_ipad
, sizeof(k_ipad
));
560 the_hash_algo
->update_fn(&ctx
, text
, text_len
);
561 the_hash_algo
->final_fn(out
, &ctx
);
563 /* RFC 2104 2. (6) & (7) */
564 the_hash_algo
->init_fn(&ctx
);
565 the_hash_algo
->update_fn(&ctx
, k_opad
, sizeof(k_opad
));
566 the_hash_algo
->update_fn(&ctx
, out
, the_hash_algo
->rawsz
);
567 the_hash_algo
->final_fn(out
, &ctx
);
570 static char *prepare_push_cert_nonce(const char *path
, timestamp_t stamp
)
572 struct strbuf buf
= STRBUF_INIT
;
573 unsigned char hash
[GIT_MAX_RAWSZ
];
575 strbuf_addf(&buf
, "%s:%"PRItime
, path
, stamp
);
576 hmac_hash(hash
, buf
.buf
, buf
.len
, cert_nonce_seed
, strlen(cert_nonce_seed
));
577 strbuf_release(&buf
);
579 /* RFC 2104 5. HMAC-SHA1 or HMAC-SHA256 */
580 strbuf_addf(&buf
, "%"PRItime
"-%.*s", stamp
, (int)the_hash_algo
->hexsz
, hash_to_hex(hash
));
581 return strbuf_detach(&buf
, NULL
);
584 static char *find_header(const char *msg
, size_t len
, const char *key
,
585 const char **next_line
)
588 const char *val
= find_header_mem(msg
, len
, key
, &out_len
);
594 *next_line
= val
+ out_len
+ 1;
596 return xmemdupz(val
, out_len
);
600 * Return zero if a and b are equal up to n bytes and nonzero if they are not.
601 * This operation is guaranteed to run in constant time to avoid leaking data.
603 static int constant_memequal(const char *a
, const char *b
, size_t n
)
608 for (i
= 0; i
< n
; i
++)
613 static const char *check_nonce(const char *buf
, size_t len
)
615 char *nonce
= find_header(buf
, len
, "nonce", NULL
);
616 timestamp_t stamp
, ostamp
;
617 char *bohmac
, *expect
= NULL
;
618 const char *retval
= NONCE_BAD
;
622 retval
= NONCE_MISSING
;
624 } else if (!push_cert_nonce
) {
625 retval
= NONCE_UNSOLICITED
;
627 } else if (!strcmp(push_cert_nonce
, nonce
)) {
632 if (!stateless_rpc
) {
633 /* returned nonce MUST match what we gave out earlier */
639 * In stateless mode, we may be receiving a nonce issued by
640 * another instance of the server that serving the same
641 * repository, and the timestamps may not match, but the
642 * nonce-seed and dir should match, so we can recompute and
643 * report the time slop.
645 * In addition, when a nonce issued by another instance has
646 * timestamp within receive.certnonceslop seconds, we pretend
647 * as if we issued that nonce when reporting to the hook.
650 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
651 if (*nonce
<= '0' || '9' < *nonce
) {
655 stamp
= parse_timestamp(nonce
, &bohmac
, 10);
656 if (bohmac
== nonce
|| bohmac
[0] != '-') {
661 noncelen
= strlen(nonce
);
662 expect
= prepare_push_cert_nonce(service_dir
, stamp
);
663 if (noncelen
!= strlen(expect
)) {
664 /* This is not even the right size. */
668 if (constant_memequal(expect
, nonce
, noncelen
)) {
669 /* Not what we would have signed earlier */
675 * By how many seconds is this nonce stale? Negative value
676 * would mean it was issued by another server with its clock
677 * skewed in the future.
679 ostamp
= parse_timestamp(push_cert_nonce
, NULL
, 10);
680 nonce_stamp_slop
= (long)ostamp
- (long)stamp
;
682 if (nonce_stamp_slop_limit
&&
683 labs(nonce_stamp_slop
) <= nonce_stamp_slop_limit
) {
685 * Pretend as if the received nonce (which passes the
686 * HMAC check, so it is not a forged by third-party)
689 free((void *)push_cert_nonce
);
690 push_cert_nonce
= xstrdup(nonce
);
703 * Return 1 if there is no push_cert or if the push options in push_cert are
704 * the same as those in the argument; 0 otherwise.
706 static int check_cert_push_options(const struct string_list
*push_options
)
708 const char *buf
= push_cert
.buf
;
709 int len
= push_cert
.len
;
712 const char *next_line
;
713 int options_seen
= 0;
720 while ((option
= find_header(buf
, len
, "push-option", &next_line
))) {
721 len
-= (next_line
- buf
);
724 if (options_seen
> push_options
->nr
726 push_options
->items
[options_seen
- 1].string
)) {
733 if (options_seen
!= push_options
->nr
)
741 static void prepare_push_cert_sha1(struct child_process
*proc
)
743 static int already_done
;
749 int bogs
/* beginning_of_gpg_sig */;
752 if (write_object_file(push_cert
.buf
, push_cert
.len
, "blob",
754 oidclr(&push_cert_oid
);
756 memset(&sigcheck
, '\0', sizeof(sigcheck
));
758 bogs
= parse_signed_buffer(push_cert
.buf
, push_cert
.len
);
759 sigcheck
.payload
= xmemdupz(push_cert
.buf
, bogs
);
760 sigcheck
.payload_len
= bogs
;
761 check_signature(&sigcheck
, push_cert
.buf
+ bogs
,
762 push_cert
.len
- bogs
);
764 nonce_status
= check_nonce(push_cert
.buf
, bogs
);
766 if (!is_null_oid(&push_cert_oid
)) {
767 strvec_pushf(&proc
->env_array
, "GIT_PUSH_CERT=%s",
768 oid_to_hex(&push_cert_oid
));
769 strvec_pushf(&proc
->env_array
, "GIT_PUSH_CERT_SIGNER=%s",
770 sigcheck
.signer
? sigcheck
.signer
: "");
771 strvec_pushf(&proc
->env_array
, "GIT_PUSH_CERT_KEY=%s",
772 sigcheck
.key
? sigcheck
.key
: "");
773 strvec_pushf(&proc
->env_array
, "GIT_PUSH_CERT_STATUS=%c",
775 if (push_cert_nonce
) {
776 strvec_pushf(&proc
->env_array
,
777 "GIT_PUSH_CERT_NONCE=%s",
779 strvec_pushf(&proc
->env_array
,
780 "GIT_PUSH_CERT_NONCE_STATUS=%s",
782 if (nonce_status
== NONCE_SLOP
)
783 strvec_pushf(&proc
->env_array
,
784 "GIT_PUSH_CERT_NONCE_SLOP=%ld",
790 struct receive_hook_feed_state
{
792 struct ref_push_report
*report
;
795 const struct string_list
*push_options
;
798 typedef int (*feed_fn
)(void *, const char **, size_t *);
799 static int run_and_feed_hook(const char *hook_name
, feed_fn feed
,
800 struct receive_hook_feed_state
*feed_state
)
802 struct child_process proc
= CHILD_PROCESS_INIT
;
805 const char *hook_path
= find_hook(hook_name
);
810 strvec_push(&proc
.args
, hook_path
);
812 proc
.stdout_to_stderr
= 1;
813 proc
.trace2_hook_name
= hook_name
;
815 if (feed_state
->push_options
) {
817 for (i
= 0; i
< feed_state
->push_options
->nr
; i
++)
818 strvec_pushf(&proc
.env_array
,
819 "GIT_PUSH_OPTION_%d=%s", i
,
820 feed_state
->push_options
->items
[i
].string
);
821 strvec_pushf(&proc
.env_array
, "GIT_PUSH_OPTION_COUNT=%d",
822 feed_state
->push_options
->nr
);
824 strvec_pushf(&proc
.env_array
, "GIT_PUSH_OPTION_COUNT");
827 strvec_pushv(&proc
.env_array
, tmp_objdir_env(tmp_objdir
));
830 memset(&muxer
, 0, sizeof(muxer
));
831 muxer
.proc
= copy_to_sideband
;
833 code
= start_async(&muxer
);
839 prepare_push_cert_sha1(&proc
);
841 code
= start_command(&proc
);
844 finish_async(&muxer
);
848 sigchain_push(SIGPIPE
, SIG_IGN
);
853 if (feed(feed_state
, &buf
, &n
))
855 if (write_in_full(proc
.in
, buf
, n
) < 0)
860 finish_async(&muxer
);
862 sigchain_pop(SIGPIPE
);
864 return finish_command(&proc
);
867 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
869 struct receive_hook_feed_state
*state
= state_
;
870 struct command
*cmd
= state
->cmd
;
873 state
->skip_broken
&& (cmd
->error_string
|| cmd
->did_not_exist
))
878 return 0; /* OK, can feed something. */
879 strbuf_reset(&state
->buf
);
881 state
->report
= cmd
->report
;
883 struct object_id
*old_oid
;
884 struct object_id
*new_oid
;
885 const char *ref_name
;
887 old_oid
= state
->report
->old_oid
? state
->report
->old_oid
: &cmd
->old_oid
;
888 new_oid
= state
->report
->new_oid
? state
->report
->new_oid
: &cmd
->new_oid
;
889 ref_name
= state
->report
->ref_name
? state
->report
->ref_name
: cmd
->ref_name
;
890 strbuf_addf(&state
->buf
, "%s %s %s\n",
891 oid_to_hex(old_oid
), oid_to_hex(new_oid
),
893 state
->report
= state
->report
->next
;
895 state
->cmd
= cmd
->next
;
897 strbuf_addf(&state
->buf
, "%s %s %s\n",
898 oid_to_hex(&cmd
->old_oid
), oid_to_hex(&cmd
->new_oid
),
900 state
->cmd
= cmd
->next
;
903 *bufp
= state
->buf
.buf
;
904 *sizep
= state
->buf
.len
;
909 static int run_receive_hook(struct command
*commands
,
910 const char *hook_name
,
912 const struct string_list
*push_options
)
914 struct receive_hook_feed_state state
;
917 strbuf_init(&state
.buf
, 0);
918 state
.cmd
= commands
;
919 state
.skip_broken
= skip_broken
;
921 if (feed_receive_hook(&state
, NULL
, NULL
))
923 state
.cmd
= commands
;
924 state
.push_options
= push_options
;
925 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
926 strbuf_release(&state
.buf
);
930 static int run_update_hook(struct command
*cmd
)
932 struct child_process proc
= CHILD_PROCESS_INIT
;
934 const char *hook_path
= find_hook("update");
939 strvec_push(&proc
.args
, hook_path
);
940 strvec_push(&proc
.args
, cmd
->ref_name
);
941 strvec_push(&proc
.args
, oid_to_hex(&cmd
->old_oid
));
942 strvec_push(&proc
.args
, oid_to_hex(&cmd
->new_oid
));
945 proc
.stdout_to_stderr
= 1;
946 proc
.err
= use_sideband
? -1 : 0;
947 proc
.trace2_hook_name
= "update";
949 code
= start_command(&proc
);
953 copy_to_sideband(proc
.err
, -1, NULL
);
954 return finish_command(&proc
);
957 static struct command
*find_command_by_refname(struct command
*list
,
960 for (; list
; list
= list
->next
)
961 if (!strcmp(list
->ref_name
, refname
))
966 static int read_proc_receive_report(struct packet_reader
*reader
,
967 struct command
*commands
,
968 struct strbuf
*errmsg
)
971 struct command
*hint
= NULL
;
972 struct ref_push_report
*report
= NULL
;
979 struct object_id old_oid
, new_oid
;
983 enum packet_read_status status
;
985 status
= packet_reader_read(reader
);
986 if (status
!= PACKET_READ_NORMAL
) {
987 /* Check whether proc-receive exited abnormally */
988 if (status
== PACKET_READ_EOF
&& !response
) {
989 strbuf_addstr(errmsg
, "proc-receive exited abnormally");
997 p
= strchr(head
, ' ');
999 strbuf_addf(errmsg
, "proc-receive reported incomplete status line: '%s'\n", head
);
1004 if (!strcmp(head
, "option")) {
1005 const char *key
, *val
;
1007 if (!hint
|| !(report
|| new_report
)) {
1009 strbuf_addstr(errmsg
, "proc-receive reported 'option' without a matching 'ok/ng' directive\n");
1014 if (!hint
->report
) {
1015 CALLOC_ARRAY(hint
->report
, 1);
1016 report
= hint
->report
;
1018 report
= hint
->report
;
1019 while (report
->next
)
1020 report
= report
->next
;
1021 report
->next
= xcalloc(1, sizeof(struct ref_push_report
));
1022 report
= report
->next
;
1027 p
= strchr(key
, ' ');
1031 if (!strcmp(key
, "refname"))
1032 report
->ref_name
= xstrdup_or_null(val
);
1033 else if (!strcmp(key
, "old-oid") && val
&&
1034 !parse_oid_hex(val
, &old_oid
, &val
))
1035 report
->old_oid
= oiddup(&old_oid
);
1036 else if (!strcmp(key
, "new-oid") && val
&&
1037 !parse_oid_hex(val
, &new_oid
, &val
))
1038 report
->new_oid
= oiddup(&new_oid
);
1039 else if (!strcmp(key
, "forced-update"))
1040 report
->forced_update
= 1;
1041 else if (!strcmp(key
, "fall-through"))
1042 /* Fall through, let 'receive-pack' to execute it. */
1043 hint
->run_proc_receive
= 0;
1050 p
= strchr(refname
, ' ');
1053 if (strcmp(head
, "ok") && strcmp(head
, "ng")) {
1054 strbuf_addf(errmsg
, "proc-receive reported bad status '%s' on ref '%s'\n",
1060 /* first try searching at our hint, falling back to all refs */
1062 hint
= find_command_by_refname(hint
, refname
);
1064 hint
= find_command_by_refname(commands
, refname
);
1066 strbuf_addf(errmsg
, "proc-receive reported status on unknown ref: %s\n",
1071 if (!hint
->run_proc_receive
) {
1072 strbuf_addf(errmsg
, "proc-receive reported status on unexpected ref: %s\n",
1077 hint
->run_proc_receive
|= RUN_PROC_RECEIVE_RETURNED
;
1078 if (!strcmp(head
, "ng")) {
1080 hint
->error_string
= xstrdup(p
);
1082 hint
->error_string
= "failed";
1089 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1090 if (cmd
->run_proc_receive
&& !cmd
->error_string
&&
1091 !(cmd
->run_proc_receive
& RUN_PROC_RECEIVE_RETURNED
)) {
1092 cmd
->error_string
= "proc-receive failed to report status";
1098 static int run_proc_receive_hook(struct command
*commands
,
1099 const struct string_list
*push_options
)
1101 struct child_process proc
= CHILD_PROCESS_INIT
;
1103 struct command
*cmd
;
1104 struct packet_reader reader
;
1105 struct strbuf cap
= STRBUF_INIT
;
1106 struct strbuf errmsg
= STRBUF_INIT
;
1107 int hook_use_push_options
= 0;
1110 const char *hook_path
= find_hook("proc-receive");
1113 rp_error("cannot find hook 'proc-receive'");
1117 strvec_push(&proc
.args
, hook_path
);
1120 proc
.trace2_hook_name
= "proc-receive";
1123 memset(&muxer
, 0, sizeof(muxer
));
1124 muxer
.proc
= copy_to_sideband
;
1126 code
= start_async(&muxer
);
1129 proc
.err
= muxer
.in
;
1134 code
= start_command(&proc
);
1137 finish_async(&muxer
);
1141 sigchain_push(SIGPIPE
, SIG_IGN
);
1143 /* Version negotiaton */
1144 packet_reader_init(&reader
, proc
.out
, NULL
, 0,
1145 PACKET_READ_CHOMP_NEWLINE
|
1146 PACKET_READ_GENTLE_ON_EOF
);
1148 strbuf_addstr(&cap
, " atomic");
1149 if (use_push_options
)
1150 strbuf_addstr(&cap
, " push-options");
1152 code
= packet_write_fmt_gently(proc
.in
, "version=1%c%s\n", '\0', cap
.buf
+ 1);
1153 strbuf_release(&cap
);
1155 code
= packet_write_fmt_gently(proc
.in
, "version=1\n");
1158 code
= packet_flush_gently(proc
.in
);
1163 enum packet_read_status status
;
1165 status
= packet_reader_read(&reader
);
1166 if (status
!= PACKET_READ_NORMAL
) {
1167 /* Check whether proc-receive exited abnormally */
1168 if (status
== PACKET_READ_EOF
)
1173 if (reader
.pktlen
> 8 && starts_with(reader
.line
, "version=")) {
1174 version
= atoi(reader
.line
+ 8);
1175 linelen
= strlen(reader
.line
);
1176 if (linelen
< reader
.pktlen
) {
1177 const char *feature_list
= reader
.line
+ linelen
+ 1;
1178 if (parse_feature_request(feature_list
, "push-options"))
1179 hook_use_push_options
= 1;
1185 strbuf_addstr(&errmsg
, "fail to negotiate version with proc-receive hook");
1195 strbuf_addf(&errmsg
, "proc-receive version '%d' is not supported",
1202 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1203 if (!cmd
->run_proc_receive
|| cmd
->skip_update
|| cmd
->error_string
)
1205 code
= packet_write_fmt_gently(proc
.in
, "%s %s %s",
1206 oid_to_hex(&cmd
->old_oid
),
1207 oid_to_hex(&cmd
->new_oid
),
1213 code
= packet_flush_gently(proc
.in
);
1215 strbuf_addstr(&errmsg
, "fail to write commands to proc-receive hook");
1219 /* Send push options */
1220 if (hook_use_push_options
) {
1221 struct string_list_item
*item
;
1223 for_each_string_list_item(item
, push_options
) {
1224 code
= packet_write_fmt_gently(proc
.in
, "%s", item
->string
);
1229 code
= packet_flush_gently(proc
.in
);
1231 strbuf_addstr(&errmsg
,
1232 "fail to write push-options to proc-receive hook");
1237 /* Read result from proc-receive */
1238 code
= read_proc_receive_report(&reader
, commands
, &errmsg
);
1244 finish_async(&muxer
);
1245 if (finish_command(&proc
))
1247 if (errmsg
.len
>0) {
1248 char *p
= errmsg
.buf
;
1250 p
+= errmsg
.len
- 1;
1253 rp_error("%s", errmsg
.buf
);
1254 strbuf_release(&errmsg
);
1256 sigchain_pop(SIGPIPE
);
1261 static char *refuse_unconfigured_deny_msg
=
1262 N_("By default, updating the current branch in a non-bare repository\n"
1263 "is denied, because it will make the index and work tree inconsistent\n"
1264 "with what you pushed, and will require 'git reset --hard' to match\n"
1265 "the work tree to HEAD.\n"
1267 "You can set the 'receive.denyCurrentBranch' configuration variable\n"
1268 "to 'ignore' or 'warn' in the remote repository to allow pushing into\n"
1269 "its current branch; however, this is not recommended unless you\n"
1270 "arranged to update its work tree to match what you pushed in some\n"
1273 "To squelch this message and still keep the default behaviour, set\n"
1274 "'receive.denyCurrentBranch' configuration variable to 'refuse'.");
1276 static void refuse_unconfigured_deny(void)
1278 rp_error("%s", _(refuse_unconfigured_deny_msg
));
1281 static char *refuse_unconfigured_deny_delete_current_msg
=
1282 N_("By default, deleting the current branch is denied, because the next\n"
1283 "'git clone' won't result in any file checked out, causing confusion.\n"
1285 "You can set 'receive.denyDeleteCurrent' configuration variable to\n"
1286 "'warn' or 'ignore' in the remote repository to allow deleting the\n"
1287 "current branch, with or without a warning message.\n"
1289 "To squelch this message, you can set it to 'refuse'.");
1291 static void refuse_unconfigured_deny_delete_current(void)
1293 rp_error("%s", _(refuse_unconfigured_deny_delete_current_msg
));
1296 static const struct object_id
*command_singleton_iterator(void *cb_data
);
1297 static int update_shallow_ref(struct command
*cmd
, struct shallow_info
*si
)
1299 struct shallow_lock shallow_lock
= SHALLOW_LOCK_INIT
;
1300 struct oid_array extra
= OID_ARRAY_INIT
;
1301 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1302 uint32_t mask
= 1 << (cmd
->index
% 32);
1305 trace_printf_key(&trace_shallow
,
1306 "shallow: update_shallow_ref %s\n", cmd
->ref_name
);
1307 for (i
= 0; i
< si
->shallow
->nr
; i
++)
1308 if (si
->used_shallow
[i
] &&
1309 (si
->used_shallow
[i
][cmd
->index
/ 32] & mask
) &&
1310 !delayed_reachability_test(si
, i
))
1311 oid_array_append(&extra
, &si
->shallow
->oid
[i
]);
1313 opt
.env
= tmp_objdir_env(tmp_objdir
);
1314 setup_alternate_shallow(&shallow_lock
, &opt
.shallow_file
, &extra
);
1315 if (check_connected(command_singleton_iterator
, cmd
, &opt
)) {
1316 rollback_shallow_file(the_repository
, &shallow_lock
);
1317 oid_array_clear(&extra
);
1321 commit_shallow_file(the_repository
, &shallow_lock
);
1324 * Make sure setup_alternate_shallow() for the next ref does
1325 * not lose these new roots..
1327 for (i
= 0; i
< extra
.nr
; i
++)
1328 register_shallow(the_repository
, &extra
.oid
[i
]);
1330 si
->shallow_ref
[cmd
->index
] = 0;
1331 oid_array_clear(&extra
);
1336 * NEEDSWORK: we should consolidate various implementions of "are we
1337 * on an unborn branch?" test into one, and make the unified one more
1338 * robust. !get_sha1() based check used here and elsewhere would not
1339 * allow us to tell an unborn branch from corrupt ref, for example.
1340 * For the purpose of fixing "deploy-to-update does not work when
1341 * pushing into an empty repository" issue, this should suffice for
1344 static int head_has_history(void)
1346 struct object_id oid
;
1348 return !get_oid("HEAD", &oid
);
1351 static const char *push_to_deploy(unsigned char *sha1
,
1353 const char *work_tree
)
1355 struct child_process child
= CHILD_PROCESS_INIT
;
1357 strvec_pushl(&child
.args
, "update-index", "-q", "--ignore-submodules",
1359 strvec_pushv(&child
.env_array
, env
->v
);
1360 child
.dir
= work_tree
;
1362 child
.stdout_to_stderr
= 1;
1364 if (run_command(&child
))
1365 return "Up-to-date check failed";
1367 /* run_command() does not clean up completely; reinitialize */
1368 child_process_init(&child
);
1369 strvec_pushl(&child
.args
, "diff-files", "--quiet",
1370 "--ignore-submodules", "--", NULL
);
1371 strvec_pushv(&child
.env_array
, env
->v
);
1372 child
.dir
= work_tree
;
1374 child
.stdout_to_stderr
= 1;
1376 if (run_command(&child
))
1377 return "Working directory has unstaged changes";
1379 child_process_init(&child
);
1380 strvec_pushl(&child
.args
, "diff-index", "--quiet", "--cached",
1381 "--ignore-submodules",
1382 /* diff-index with either HEAD or an empty tree */
1383 head_has_history() ? "HEAD" : empty_tree_oid_hex(),
1385 strvec_pushv(&child
.env_array
, env
->v
);
1387 child
.no_stdout
= 1;
1388 child
.stdout_to_stderr
= 0;
1390 if (run_command(&child
))
1391 return "Working directory has staged changes";
1393 child_process_init(&child
);
1394 strvec_pushl(&child
.args
, "read-tree", "-u", "-m", hash_to_hex(sha1
),
1396 strvec_pushv(&child
.env_array
, env
->v
);
1397 child
.dir
= work_tree
;
1399 child
.no_stdout
= 1;
1400 child
.stdout_to_stderr
= 0;
1402 if (run_command(&child
))
1403 return "Could not update working tree to new HEAD";
1408 static const char *push_to_checkout_hook
= "push-to-checkout";
1410 static const char *push_to_checkout(unsigned char *hash
,
1412 const char *work_tree
)
1414 struct run_hooks_opt opt
= RUN_HOOKS_OPT_INIT
;
1416 strvec_pushf(env
, "GIT_WORK_TREE=%s", absolute_path(work_tree
));
1417 strvec_pushv(&opt
.env
, env
->v
);
1418 strvec_push(&opt
.args
, hash_to_hex(hash
));
1419 if (run_hooks_opt(push_to_checkout_hook
, &opt
))
1420 return "push-to-checkout hook declined";
1425 static const char *update_worktree(unsigned char *sha1
, const struct worktree
*worktree
)
1427 const char *retval
, *git_dir
;
1428 struct strvec env
= STRVEC_INIT
;
1430 if (!worktree
|| !worktree
->path
)
1431 BUG("worktree->path must be non-NULL");
1433 if (worktree
->is_bare
)
1434 return "denyCurrentBranch = updateInstead needs a worktree";
1435 git_dir
= get_worktree_git_dir(worktree
);
1437 strvec_pushf(&env
, "GIT_DIR=%s", absolute_path(git_dir
));
1439 if (!hook_exists(push_to_checkout_hook
))
1440 retval
= push_to_deploy(sha1
, &env
, worktree
->path
);
1442 retval
= push_to_checkout(sha1
, &env
, worktree
->path
);
1448 static const char *update(struct command
*cmd
, struct shallow_info
*si
)
1450 const char *name
= cmd
->ref_name
;
1451 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
1452 static char *namespaced_name
;
1454 struct object_id
*old_oid
= &cmd
->old_oid
;
1455 struct object_id
*new_oid
= &cmd
->new_oid
;
1456 int do_update_worktree
= 0;
1457 struct worktree
**worktrees
= get_worktrees();
1458 const struct worktree
*worktree
=
1459 find_shared_symref(worktrees
, "HEAD", name
);
1461 /* only refs/... are allowed */
1462 if (!starts_with(name
, "refs/") || check_refname_format(name
+ 5, 0)) {
1463 rp_error("refusing to create funny ref '%s' remotely", name
);
1464 ret
= "funny refname";
1468 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
1469 free(namespaced_name
);
1470 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
1472 if (worktree
&& !worktree
->is_bare
) {
1473 switch (deny_current_branch
) {
1477 rp_warning("updating the current branch");
1480 case DENY_UNCONFIGURED
:
1481 rp_error("refusing to update checked out branch: %s", name
);
1482 if (deny_current_branch
== DENY_UNCONFIGURED
)
1483 refuse_unconfigured_deny();
1484 ret
= "branch is currently checked out";
1486 case DENY_UPDATE_INSTEAD
:
1487 /* pass -- let other checks intervene first */
1488 do_update_worktree
= 1;
1493 if (!is_null_oid(new_oid
) && !has_object_file(new_oid
)) {
1494 error("unpack should have generated %s, "
1495 "but I can't find it!", oid_to_hex(new_oid
));
1500 if (!is_null_oid(old_oid
) && is_null_oid(new_oid
)) {
1501 if (deny_deletes
&& starts_with(name
, "refs/heads/")) {
1502 rp_error("denying ref deletion for %s", name
);
1503 ret
= "deletion prohibited";
1507 if (worktree
|| (head_name
&& !strcmp(namespaced_name
, head_name
))) {
1508 switch (deny_delete_current
) {
1512 rp_warning("deleting the current branch");
1515 case DENY_UNCONFIGURED
:
1516 case DENY_UPDATE_INSTEAD
:
1517 if (deny_delete_current
== DENY_UNCONFIGURED
)
1518 refuse_unconfigured_deny_delete_current();
1519 rp_error("refusing to delete the current branch: %s", name
);
1520 ret
= "deletion of the current branch prohibited";
1523 ret
= "Invalid denyDeleteCurrent setting";
1529 if (deny_non_fast_forwards
&& !is_null_oid(new_oid
) &&
1530 !is_null_oid(old_oid
) &&
1531 starts_with(name
, "refs/heads/")) {
1532 struct object
*old_object
, *new_object
;
1533 struct commit
*old_commit
, *new_commit
;
1535 old_object
= parse_object(the_repository
, old_oid
);
1536 new_object
= parse_object(the_repository
, new_oid
);
1538 if (!old_object
|| !new_object
||
1539 old_object
->type
!= OBJ_COMMIT
||
1540 new_object
->type
!= OBJ_COMMIT
) {
1541 error("bad sha1 objects for %s", name
);
1545 old_commit
= (struct commit
*)old_object
;
1546 new_commit
= (struct commit
*)new_object
;
1547 if (!in_merge_bases(old_commit
, new_commit
)) {
1548 rp_error("denying non-fast-forward %s"
1549 " (you should pull first)", name
);
1550 ret
= "non-fast-forward";
1554 if (run_update_hook(cmd
)) {
1555 rp_error("hook declined to update %s", name
);
1556 ret
= "hook declined";
1560 if (do_update_worktree
) {
1561 ret
= update_worktree(new_oid
->hash
, worktree
);
1566 if (is_null_oid(new_oid
)) {
1567 struct strbuf err
= STRBUF_INIT
;
1568 if (!parse_object(the_repository
, old_oid
)) {
1570 if (ref_exists(name
)) {
1571 rp_warning("allowing deletion of corrupt ref");
1573 rp_warning("deleting a non-existent ref");
1574 cmd
->did_not_exist
= 1;
1577 if (ref_transaction_delete(transaction
,
1581 rp_error("%s", err
.buf
);
1582 ret
= "failed to delete";
1584 ret
= NULL
; /* good */
1586 strbuf_release(&err
);
1589 struct strbuf err
= STRBUF_INIT
;
1590 if (shallow_update
&& si
->shallow_ref
[cmd
->index
] &&
1591 update_shallow_ref(cmd
, si
)) {
1592 ret
= "shallow error";
1596 if (ref_transaction_update(transaction
,
1601 rp_error("%s", err
.buf
);
1602 ret
= "failed to update ref";
1604 ret
= NULL
; /* good */
1606 strbuf_release(&err
);
1610 free_worktrees(worktrees
);
1614 static void run_update_post_hook(struct command
*commands
)
1616 struct command
*cmd
;
1617 struct child_process proc
= CHILD_PROCESS_INIT
;
1620 hook
= find_hook("post-update");
1624 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1625 if (cmd
->error_string
|| cmd
->did_not_exist
)
1628 strvec_push(&proc
.args
, hook
);
1629 strvec_push(&proc
.args
, cmd
->ref_name
);
1635 proc
.stdout_to_stderr
= 1;
1636 proc
.err
= use_sideband
? -1 : 0;
1637 proc
.trace2_hook_name
= "post-update";
1639 if (!start_command(&proc
)) {
1641 copy_to_sideband(proc
.err
, -1, NULL
);
1642 finish_command(&proc
);
1646 static void check_aliased_update_internal(struct command
*cmd
,
1647 struct string_list
*list
,
1648 const char *dst_name
, int flag
)
1650 struct string_list_item
*item
;
1651 struct command
*dst_cmd
;
1653 if (!(flag
& REF_ISSYMREF
))
1657 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
1658 cmd
->skip_update
= 1;
1659 cmd
->error_string
= "broken symref";
1662 dst_name
= strip_namespace(dst_name
);
1664 if ((item
= string_list_lookup(list
, dst_name
)) == NULL
)
1667 cmd
->skip_update
= 1;
1669 dst_cmd
= (struct command
*) item
->util
;
1671 if (oideq(&cmd
->old_oid
, &dst_cmd
->old_oid
) &&
1672 oideq(&cmd
->new_oid
, &dst_cmd
->new_oid
))
1675 dst_cmd
->skip_update
= 1;
1677 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1678 " its target '%s' (%s..%s)",
1680 find_unique_abbrev(&cmd
->old_oid
, DEFAULT_ABBREV
),
1681 find_unique_abbrev(&cmd
->new_oid
, DEFAULT_ABBREV
),
1683 find_unique_abbrev(&dst_cmd
->old_oid
, DEFAULT_ABBREV
),
1684 find_unique_abbrev(&dst_cmd
->new_oid
, DEFAULT_ABBREV
));
1686 cmd
->error_string
= dst_cmd
->error_string
=
1687 "inconsistent aliased update";
1690 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
1692 struct strbuf buf
= STRBUF_INIT
;
1693 const char *dst_name
;
1696 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
1697 dst_name
= resolve_ref_unsafe(buf
.buf
, 0, NULL
, &flag
);
1698 check_aliased_update_internal(cmd
, list
, dst_name
, flag
);
1699 strbuf_release(&buf
);
1702 static void check_aliased_updates(struct command
*commands
)
1704 struct command
*cmd
;
1705 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
1707 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1708 struct string_list_item
*item
=
1709 string_list_append(&ref_list
, cmd
->ref_name
);
1710 item
->util
= (void *)cmd
;
1712 string_list_sort(&ref_list
);
1714 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1715 if (!cmd
->error_string
)
1716 check_aliased_update(cmd
, &ref_list
);
1719 string_list_clear(&ref_list
, 0);
1722 static const struct object_id
*command_singleton_iterator(void *cb_data
)
1724 struct command
**cmd_list
= cb_data
;
1725 struct command
*cmd
= *cmd_list
;
1727 if (!cmd
|| is_null_oid(&cmd
->new_oid
))
1729 *cmd_list
= NULL
; /* this returns only one */
1730 return &cmd
->new_oid
;
1733 static void set_connectivity_errors(struct command
*commands
,
1734 struct shallow_info
*si
)
1736 struct command
*cmd
;
1738 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1739 struct command
*singleton
= cmd
;
1740 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1742 if (shallow_update
&& si
->shallow_ref
[cmd
->index
])
1743 /* to be checked in update_shallow_ref() */
1746 opt
.env
= tmp_objdir_env(tmp_objdir
);
1747 if (!check_connected(command_singleton_iterator
, &singleton
,
1751 cmd
->error_string
= "missing necessary objects";
1755 struct iterate_data
{
1756 struct command
*cmds
;
1757 struct shallow_info
*si
;
1760 static const struct object_id
*iterate_receive_command_list(void *cb_data
)
1762 struct iterate_data
*data
= cb_data
;
1763 struct command
**cmd_list
= &data
->cmds
;
1764 struct command
*cmd
= *cmd_list
;
1766 for (; cmd
; cmd
= cmd
->next
) {
1767 if (shallow_update
&& data
->si
->shallow_ref
[cmd
->index
])
1768 /* to be checked in update_shallow_ref() */
1770 if (!is_null_oid(&cmd
->new_oid
) && !cmd
->skip_update
) {
1771 *cmd_list
= cmd
->next
;
1772 return &cmd
->new_oid
;
1778 static void reject_updates_to_hidden(struct command
*commands
)
1780 struct strbuf refname_full
= STRBUF_INIT
;
1782 struct command
*cmd
;
1784 strbuf_addstr(&refname_full
, get_git_namespace());
1785 prefix_len
= refname_full
.len
;
1787 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1788 if (cmd
->error_string
)
1791 strbuf_setlen(&refname_full
, prefix_len
);
1792 strbuf_addstr(&refname_full
, cmd
->ref_name
);
1794 if (!ref_is_hidden(cmd
->ref_name
, refname_full
.buf
))
1796 if (is_null_oid(&cmd
->new_oid
))
1797 cmd
->error_string
= "deny deleting a hidden ref";
1799 cmd
->error_string
= "deny updating a hidden ref";
1802 strbuf_release(&refname_full
);
1805 static int should_process_cmd(struct command
*cmd
)
1807 return !cmd
->error_string
&& !cmd
->skip_update
;
1810 static void warn_if_skipped_connectivity_check(struct command
*commands
,
1811 struct shallow_info
*si
)
1813 struct command
*cmd
;
1814 int checked_connectivity
= 1;
1816 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1817 if (should_process_cmd(cmd
) && si
->shallow_ref
[cmd
->index
]) {
1818 error("BUG: connectivity check has not been run on ref %s",
1820 checked_connectivity
= 0;
1823 if (!checked_connectivity
)
1824 BUG("connectivity check skipped???");
1827 static void execute_commands_non_atomic(struct command
*commands
,
1828 struct shallow_info
*si
)
1830 struct command
*cmd
;
1831 struct strbuf err
= STRBUF_INIT
;
1833 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1834 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1837 transaction
= ref_transaction_begin(&err
);
1839 rp_error("%s", err
.buf
);
1841 cmd
->error_string
= "transaction failed to start";
1845 cmd
->error_string
= update(cmd
, si
);
1847 if (!cmd
->error_string
1848 && ref_transaction_commit(transaction
, &err
)) {
1849 rp_error("%s", err
.buf
);
1851 cmd
->error_string
= "failed to update ref";
1853 ref_transaction_free(transaction
);
1855 strbuf_release(&err
);
1858 static void execute_commands_atomic(struct command
*commands
,
1859 struct shallow_info
*si
)
1861 struct command
*cmd
;
1862 struct strbuf err
= STRBUF_INIT
;
1863 const char *reported_error
= "atomic push failure";
1865 transaction
= ref_transaction_begin(&err
);
1867 rp_error("%s", err
.buf
);
1869 reported_error
= "transaction failed to start";
1873 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1874 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1877 cmd
->error_string
= update(cmd
, si
);
1879 if (cmd
->error_string
)
1883 if (ref_transaction_commit(transaction
, &err
)) {
1884 rp_error("%s", err
.buf
);
1885 reported_error
= "atomic transaction failed";
1891 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1892 if (!cmd
->error_string
)
1893 cmd
->error_string
= reported_error
;
1896 ref_transaction_free(transaction
);
1897 strbuf_release(&err
);
1900 static void execute_commands(struct command
*commands
,
1901 const char *unpacker_error
,
1902 struct shallow_info
*si
,
1903 const struct string_list
*push_options
)
1905 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1906 struct command
*cmd
;
1907 struct iterate_data data
;
1910 int run_proc_receive
= 0;
1912 if (unpacker_error
) {
1913 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1914 cmd
->error_string
= "unpacker error";
1919 memset(&muxer
, 0, sizeof(muxer
));
1920 muxer
.proc
= copy_to_sideband
;
1922 if (!start_async(&muxer
))
1924 /* ...else, continue without relaying sideband */
1927 data
.cmds
= commands
;
1929 opt
.err_fd
= err_fd
;
1930 opt
.progress
= err_fd
&& !quiet
;
1931 opt
.env
= tmp_objdir_env(tmp_objdir
);
1932 if (check_connected(iterate_receive_command_list
, &data
, &opt
))
1933 set_connectivity_errors(commands
, si
);
1936 finish_async(&muxer
);
1938 reject_updates_to_hidden(commands
);
1941 * Try to find commands that have special prefix in their reference names,
1942 * and mark them to run an external "proc-receive" hook later.
1944 if (proc_receive_ref
) {
1945 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1946 if (!should_process_cmd(cmd
))
1949 if (proc_receive_ref_matches(cmd
)) {
1950 cmd
->run_proc_receive
= RUN_PROC_RECEIVE_SCHEDULED
;
1951 run_proc_receive
= 1;
1956 if (run_receive_hook(commands
, "pre-receive", 0, push_options
)) {
1957 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1958 if (!cmd
->error_string
)
1959 cmd
->error_string
= "pre-receive hook declined";
1965 * If there is no command ready to run, should return directly to destroy
1966 * temporary data in the quarantine area.
1968 for (cmd
= commands
; cmd
&& cmd
->error_string
; cmd
= cmd
->next
)
1974 * Now we'll start writing out refs, which means the objects need
1975 * to be in their final positions so that other processes can see them.
1977 if (tmp_objdir_migrate(tmp_objdir
) < 0) {
1978 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1979 if (!cmd
->error_string
)
1980 cmd
->error_string
= "unable to migrate objects to permanent storage";
1986 check_aliased_updates(commands
);
1988 free(head_name_to_free
);
1989 head_name
= head_name_to_free
= resolve_refdup("HEAD", 0, NULL
, NULL
);
1991 if (run_proc_receive
&&
1992 run_proc_receive_hook(commands
, push_options
))
1993 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1994 if (!cmd
->error_string
&&
1995 !(cmd
->run_proc_receive
& RUN_PROC_RECEIVE_RETURNED
) &&
1996 (cmd
->run_proc_receive
|| use_atomic
))
1997 cmd
->error_string
= "fail to run proc-receive hook";
2000 execute_commands_atomic(commands
, si
);
2002 execute_commands_non_atomic(commands
, si
);
2005 warn_if_skipped_connectivity_check(commands
, si
);
2008 static struct command
**queue_command(struct command
**tail
,
2012 struct object_id old_oid
, new_oid
;
2013 struct command
*cmd
;
2014 const char *refname
;
2018 if (parse_oid_hex(line
, &old_oid
, &p
) ||
2020 parse_oid_hex(p
, &new_oid
, &p
) ||
2022 die("protocol error: expected old/new/ref, got '%s'", line
);
2025 reflen
= linelen
- (p
- line
);
2026 FLEX_ALLOC_MEM(cmd
, ref_name
, refname
, reflen
);
2027 oidcpy(&cmd
->old_oid
, &old_oid
);
2028 oidcpy(&cmd
->new_oid
, &new_oid
);
2033 static void queue_commands_from_cert(struct command
**tail
,
2034 struct strbuf
*push_cert
)
2036 const char *boc
, *eoc
;
2039 die("protocol error: got both push certificate and unsigned commands");
2041 boc
= strstr(push_cert
->buf
, "\n\n");
2043 die("malformed push certificate %.*s", 100, push_cert
->buf
);
2046 eoc
= push_cert
->buf
+ parse_signed_buffer(push_cert
->buf
, push_cert
->len
);
2049 const char *eol
= memchr(boc
, '\n', eoc
- boc
);
2050 tail
= queue_command(tail
, boc
, eol
? eol
- boc
: eoc
- boc
);
2051 boc
= eol
? eol
+ 1 : eoc
;
2055 static struct command
*read_head_info(struct packet_reader
*reader
,
2056 struct oid_array
*shallow
)
2058 struct command
*commands
= NULL
;
2059 struct command
**p
= &commands
;
2063 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
2066 if (reader
->pktlen
> 8 && starts_with(reader
->line
, "shallow ")) {
2067 struct object_id oid
;
2068 if (get_oid_hex(reader
->line
+ 8, &oid
))
2069 die("protocol error: expected shallow sha, got '%s'",
2071 oid_array_append(shallow
, &oid
);
2075 linelen
= strlen(reader
->line
);
2076 if (linelen
< reader
->pktlen
) {
2077 const char *feature_list
= reader
->line
+ linelen
+ 1;
2078 const char *hash
= NULL
;
2079 const char *client_sid
;
2081 if (parse_feature_request(feature_list
, "report-status"))
2083 if (parse_feature_request(feature_list
, "report-status-v2"))
2084 report_status_v2
= 1;
2085 if (parse_feature_request(feature_list
, "side-band-64k"))
2086 use_sideband
= LARGE_PACKET_MAX
;
2087 if (parse_feature_request(feature_list
, "quiet"))
2089 if (advertise_atomic_push
2090 && parse_feature_request(feature_list
, "atomic"))
2092 if (advertise_push_options
2093 && parse_feature_request(feature_list
, "push-options"))
2094 use_push_options
= 1;
2095 hash
= parse_feature_value(feature_list
, "object-format", &len
, NULL
);
2097 hash
= hash_algos
[GIT_HASH_SHA1
].name
;
2100 if (xstrncmpz(the_hash_algo
->name
, hash
, len
))
2101 die("error: unsupported object format '%s'", hash
);
2102 client_sid
= parse_feature_value(feature_list
, "session-id", &len
, NULL
);
2104 char *sid
= xstrndup(client_sid
, len
);
2105 trace2_data_string("transfer", NULL
, "client-sid", client_sid
);
2110 if (!strcmp(reader
->line
, "push-cert")) {
2112 int saved_options
= reader
->options
;
2113 reader
->options
&= ~PACKET_READ_CHOMP_NEWLINE
;
2116 packet_reader_read(reader
);
2117 if (reader
->status
== PACKET_READ_FLUSH
) {
2121 if (reader
->status
!= PACKET_READ_NORMAL
) {
2122 die("protocol error: got an unexpected packet");
2124 if (!strcmp(reader
->line
, "push-cert-end\n"))
2125 break; /* end of cert */
2126 strbuf_addstr(&push_cert
, reader
->line
);
2128 reader
->options
= saved_options
;
2135 p
= queue_command(p
, reader
->line
, linelen
);
2139 queue_commands_from_cert(p
, &push_cert
);
2144 static void read_push_options(struct packet_reader
*reader
,
2145 struct string_list
*options
)
2148 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
2151 string_list_append(options
, reader
->line
);
2155 static const char *parse_pack_header(struct pack_header
*hdr
)
2157 switch (read_pack_header(0, hdr
)) {
2159 return "eof before pack header was fully read";
2161 case PH_ERROR_PACK_SIGNATURE
:
2162 return "protocol error (pack signature mismatch detected)";
2164 case PH_ERROR_PROTOCOL
:
2165 return "protocol error (pack version unsupported)";
2168 return "unknown error in parse_pack_header";
2175 static const char *pack_lockfile
;
2177 static void push_header_arg(struct strvec
*args
, struct pack_header
*hdr
)
2179 strvec_pushf(args
, "--pack_header=%"PRIu32
",%"PRIu32
,
2180 ntohl(hdr
->hdr_version
), ntohl(hdr
->hdr_entries
));
2183 static const char *unpack(int err_fd
, struct shallow_info
*si
)
2185 struct pack_header hdr
;
2186 const char *hdr_err
;
2188 struct child_process child
= CHILD_PROCESS_INIT
;
2189 int fsck_objects
= (receive_fsck_objects
>= 0
2190 ? receive_fsck_objects
2191 : transfer_fsck_objects
>= 0
2192 ? transfer_fsck_objects
2195 hdr_err
= parse_pack_header(&hdr
);
2202 if (si
->nr_ours
|| si
->nr_theirs
) {
2203 alt_shallow_file
= setup_temporary_shallow(si
->shallow
);
2204 strvec_push(&child
.args
, "--shallow-file");
2205 strvec_push(&child
.args
, alt_shallow_file
);
2208 tmp_objdir
= tmp_objdir_create("incoming");
2212 return "unable to create temporary object directory";
2215 strvec_pushv(&child
.env_array
, tmp_objdir_env(tmp_objdir
));
2218 * Normally we just pass the tmp_objdir environment to the child
2219 * processes that do the heavy lifting, but we may need to see these
2220 * objects ourselves to set up shallow information.
2222 tmp_objdir_add_as_alternate(tmp_objdir
);
2224 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
2225 strvec_push(&child
.args
, "unpack-objects");
2226 push_header_arg(&child
.args
, &hdr
);
2228 strvec_push(&child
.args
, "-q");
2230 strvec_pushf(&child
.args
, "--strict%s",
2231 fsck_msg_types
.buf
);
2233 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2234 (uintmax_t)max_input_size
);
2235 child
.no_stdout
= 1;
2238 status
= run_command(&child
);
2240 return "unpack-objects abnormal exit";
2242 char hostname
[HOST_NAME_MAX
+ 1];
2244 strvec_pushl(&child
.args
, "index-pack", "--stdin", NULL
);
2245 push_header_arg(&child
.args
, &hdr
);
2247 if (xgethostname(hostname
, sizeof(hostname
)))
2248 xsnprintf(hostname
, sizeof(hostname
), "localhost");
2249 strvec_pushf(&child
.args
,
2250 "--keep=receive-pack %"PRIuMAX
" on %s",
2251 (uintmax_t)getpid(),
2254 if (!quiet
&& err_fd
)
2255 strvec_push(&child
.args
, "--show-resolving-progress");
2257 strvec_push(&child
.args
, "--report-end-of-input");
2259 strvec_pushf(&child
.args
, "--strict%s",
2260 fsck_msg_types
.buf
);
2262 strvec_push(&child
.args
, "--fix-thin");
2264 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2265 (uintmax_t)max_input_size
);
2269 status
= start_command(&child
);
2271 return "index-pack fork failed";
2272 pack_lockfile
= index_pack_lockfile(child
.out
, NULL
);
2274 status
= finish_command(&child
);
2276 return "index-pack abnormal exit";
2277 reprepare_packed_git(the_repository
);
2282 static const char *unpack_with_sideband(struct shallow_info
*si
)
2288 return unpack(0, si
);
2290 use_keepalive
= KEEPALIVE_AFTER_NUL
;
2291 memset(&muxer
, 0, sizeof(muxer
));
2292 muxer
.proc
= copy_to_sideband
;
2294 if (start_async(&muxer
))
2297 ret
= unpack(muxer
.in
, si
);
2299 finish_async(&muxer
);
2303 static void prepare_shallow_update(struct shallow_info
*si
)
2305 int i
, j
, k
, bitmap_size
= DIV_ROUND_UP(si
->ref
->nr
, 32);
2307 ALLOC_ARRAY(si
->used_shallow
, si
->shallow
->nr
);
2308 assign_shallow_commits_to_refs(si
, si
->used_shallow
, NULL
);
2310 CALLOC_ARRAY(si
->need_reachability_test
, si
->shallow
->nr
);
2311 CALLOC_ARRAY(si
->reachable
, si
->shallow
->nr
);
2312 CALLOC_ARRAY(si
->shallow_ref
, si
->ref
->nr
);
2314 for (i
= 0; i
< si
->nr_ours
; i
++)
2315 si
->need_reachability_test
[si
->ours
[i
]] = 1;
2317 for (i
= 0; i
< si
->shallow
->nr
; i
++) {
2318 if (!si
->used_shallow
[i
])
2320 for (j
= 0; j
< bitmap_size
; j
++) {
2321 if (!si
->used_shallow
[i
][j
])
2323 si
->need_reachability_test
[i
]++;
2324 for (k
= 0; k
< 32; k
++)
2325 if (si
->used_shallow
[i
][j
] & (1U << k
))
2326 si
->shallow_ref
[j
* 32 + k
]++;
2330 * true for those associated with some refs and belong
2331 * in "ours" list aka "step 7 not done yet"
2333 si
->need_reachability_test
[i
] =
2334 si
->need_reachability_test
[i
] > 1;
2338 * keep hooks happy by forcing a temporary shallow file via
2339 * env variable because we can't add --shallow-file to every
2340 * command. check_connected() will be done with
2341 * true .git/shallow though.
2343 setenv(GIT_SHALLOW_FILE_ENVIRONMENT
, alt_shallow_file
, 1);
2346 static void update_shallow_info(struct command
*commands
,
2347 struct shallow_info
*si
,
2348 struct oid_array
*ref
)
2350 struct command
*cmd
;
2352 remove_nonexistent_theirs_shallow(si
);
2353 if (!si
->nr_ours
&& !si
->nr_theirs
) {
2358 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2359 if (is_null_oid(&cmd
->new_oid
))
2361 oid_array_append(ref
, &cmd
->new_oid
);
2362 cmd
->index
= ref
->nr
- 1;
2366 if (shallow_update
) {
2367 prepare_shallow_update(si
);
2371 ALLOC_ARRAY(ref_status
, ref
->nr
);
2372 assign_shallow_commits_to_refs(si
, NULL
, ref_status
);
2373 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2374 if (is_null_oid(&cmd
->new_oid
))
2376 if (ref_status
[cmd
->index
]) {
2377 cmd
->error_string
= "shallow update not allowed";
2378 cmd
->skip_update
= 1;
2384 static void report(struct command
*commands
, const char *unpack_status
)
2386 struct command
*cmd
;
2387 struct strbuf buf
= STRBUF_INIT
;
2389 packet_buf_write(&buf
, "unpack %s\n",
2390 unpack_status
? unpack_status
: "ok");
2391 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2392 if (!cmd
->error_string
)
2393 packet_buf_write(&buf
, "ok %s\n",
2396 packet_buf_write(&buf
, "ng %s %s\n",
2397 cmd
->ref_name
, cmd
->error_string
);
2399 packet_buf_flush(&buf
);
2402 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2404 write_or_die(1, buf
.buf
, buf
.len
);
2405 strbuf_release(&buf
);
2408 static void report_v2(struct command
*commands
, const char *unpack_status
)
2410 struct command
*cmd
;
2411 struct strbuf buf
= STRBUF_INIT
;
2412 struct ref_push_report
*report
;
2414 packet_buf_write(&buf
, "unpack %s\n",
2415 unpack_status
? unpack_status
: "ok");
2416 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2419 if (cmd
->error_string
) {
2420 packet_buf_write(&buf
, "ng %s %s\n",
2425 packet_buf_write(&buf
, "ok %s\n",
2427 for (report
= cmd
->report
; report
; report
= report
->next
) {
2429 packet_buf_write(&buf
, "ok %s\n",
2431 if (report
->ref_name
)
2432 packet_buf_write(&buf
, "option refname %s\n",
2434 if (report
->old_oid
)
2435 packet_buf_write(&buf
, "option old-oid %s\n",
2436 oid_to_hex(report
->old_oid
));
2437 if (report
->new_oid
)
2438 packet_buf_write(&buf
, "option new-oid %s\n",
2439 oid_to_hex(report
->new_oid
));
2440 if (report
->forced_update
)
2441 packet_buf_write(&buf
, "option forced-update\n");
2444 packet_buf_flush(&buf
);
2447 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2449 write_or_die(1, buf
.buf
, buf
.len
);
2450 strbuf_release(&buf
);
2453 static int delete_only(struct command
*commands
)
2455 struct command
*cmd
;
2456 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2457 if (!is_null_oid(&cmd
->new_oid
))
2463 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
2465 int advertise_refs
= 0;
2466 struct command
*commands
;
2467 struct oid_array shallow
= OID_ARRAY_INIT
;
2468 struct oid_array ref
= OID_ARRAY_INIT
;
2469 struct shallow_info si
;
2470 struct packet_reader reader
;
2472 struct option options
[] = {
2473 OPT__QUIET(&quiet
, N_("quiet")),
2474 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc
, NULL
),
2475 OPT_HIDDEN_BOOL(0, "http-backend-info-refs", &advertise_refs
, NULL
),
2476 OPT_ALIAS(0, "advertise-refs", "http-backend-info-refs"),
2477 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin
, NULL
),
2481 packet_trace_identity("receive-pack");
2483 argc
= parse_options(argc
, argv
, prefix
, options
, receive_pack_usage
, 0);
2486 usage_msg_opt(_("too many arguments"), receive_pack_usage
, options
);
2488 usage_msg_opt(_("you must specify a directory"), receive_pack_usage
, options
);
2490 service_dir
= argv
[0];
2494 if (!enter_repo(service_dir
, 0))
2495 die("'%s' does not appear to be a git repository", service_dir
);
2497 git_config(receive_pack_config
, NULL
);
2498 if (cert_nonce_seed
)
2499 push_cert_nonce
= prepare_push_cert_nonce(service_dir
, time(NULL
));
2501 if (0 <= transfer_unpack_limit
)
2502 unpack_limit
= transfer_unpack_limit
;
2503 else if (0 <= receive_unpack_limit
)
2504 unpack_limit
= receive_unpack_limit
;
2506 switch (determine_protocol_version_server()) {
2509 * push support for protocol v2 has not been implemented yet,
2510 * so ignore the request to use v2 and fallback to using v0.
2515 * v1 is just the original protocol with a version string,
2516 * so just fall through after writing the version string.
2518 if (advertise_refs
|| !stateless_rpc
)
2519 packet_write_fmt(1, "version 1\n");
2524 case protocol_unknown_version
:
2525 BUG("unknown protocol version");
2528 if (advertise_refs
|| !stateless_rpc
) {
2534 packet_reader_init(&reader
, 0, NULL
, 0,
2535 PACKET_READ_CHOMP_NEWLINE
|
2536 PACKET_READ_DIE_ON_ERR_PACKET
);
2538 if ((commands
= read_head_info(&reader
, &shallow
)) != NULL
) {
2539 const char *unpack_status
= NULL
;
2540 struct string_list push_options
= STRING_LIST_INIT_DUP
;
2542 if (use_push_options
)
2543 read_push_options(&reader
, &push_options
);
2544 if (!check_cert_push_options(&push_options
)) {
2545 struct command
*cmd
;
2546 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
2547 cmd
->error_string
= "inconsistent push options";
2550 prepare_shallow_info(&si
, &shallow
);
2551 if (!si
.nr_ours
&& !si
.nr_theirs
)
2553 if (!delete_only(commands
)) {
2554 unpack_status
= unpack_with_sideband(&si
);
2555 update_shallow_info(commands
, &si
, &ref
);
2557 use_keepalive
= KEEPALIVE_ALWAYS
;
2558 execute_commands(commands
, unpack_status
, &si
,
2561 unlink_or_warn(pack_lockfile
);
2562 sigchain_push(SIGPIPE
, SIG_IGN
);
2563 if (report_status_v2
)
2564 report_v2(commands
, unpack_status
);
2565 else if (report_status
)
2566 report(commands
, unpack_status
);
2567 sigchain_pop(SIGPIPE
);
2568 run_receive_hook(commands
, "post-receive", 1,
2570 run_update_post_hook(commands
);
2571 string_list_clear(&push_options
, 0);
2573 struct child_process proc
= CHILD_PROCESS_INIT
;
2576 proc
.stdout_to_stderr
= 1;
2577 proc
.err
= use_sideband
? -1 : 0;
2578 proc
.git_cmd
= proc
.close_object_store
= 1;
2579 strvec_pushl(&proc
.args
, "gc", "--auto", "--quiet",
2582 if (!start_command(&proc
)) {
2584 copy_to_sideband(proc
.err
, -1, NULL
);
2585 finish_command(&proc
);
2588 if (auto_update_server_info
)
2589 update_server_info(0);
2590 clear_shallow_info(&si
);
2594 oid_array_clear(&shallow
);
2595 oid_array_clear(&ref
);
2596 free((void *)push_cert_nonce
);