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
, OBJ_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_%"PRIuMAX
"=%s",
821 feed_state
->push_options
->items
[i
].string
);
822 strvec_pushf(&proc
.env_array
, "GIT_PUSH_OPTION_COUNT=%"PRIuMAX
"",
823 (uintmax_t)feed_state
->push_options
->nr
);
825 strvec_pushf(&proc
.env_array
, "GIT_PUSH_OPTION_COUNT");
828 strvec_pushv(&proc
.env_array
, tmp_objdir_env(tmp_objdir
));
831 memset(&muxer
, 0, sizeof(muxer
));
832 muxer
.proc
= copy_to_sideband
;
834 code
= start_async(&muxer
);
840 prepare_push_cert_sha1(&proc
);
842 code
= start_command(&proc
);
845 finish_async(&muxer
);
849 sigchain_push(SIGPIPE
, SIG_IGN
);
854 if (feed(feed_state
, &buf
, &n
))
856 if (write_in_full(proc
.in
, buf
, n
) < 0)
861 finish_async(&muxer
);
863 sigchain_pop(SIGPIPE
);
865 return finish_command(&proc
);
868 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
870 struct receive_hook_feed_state
*state
= state_
;
871 struct command
*cmd
= state
->cmd
;
874 state
->skip_broken
&& (cmd
->error_string
|| cmd
->did_not_exist
))
879 return 0; /* OK, can feed something. */
880 strbuf_reset(&state
->buf
);
882 state
->report
= cmd
->report
;
884 struct object_id
*old_oid
;
885 struct object_id
*new_oid
;
886 const char *ref_name
;
888 old_oid
= state
->report
->old_oid
? state
->report
->old_oid
: &cmd
->old_oid
;
889 new_oid
= state
->report
->new_oid
? state
->report
->new_oid
: &cmd
->new_oid
;
890 ref_name
= state
->report
->ref_name
? state
->report
->ref_name
: cmd
->ref_name
;
891 strbuf_addf(&state
->buf
, "%s %s %s\n",
892 oid_to_hex(old_oid
), oid_to_hex(new_oid
),
894 state
->report
= state
->report
->next
;
896 state
->cmd
= cmd
->next
;
898 strbuf_addf(&state
->buf
, "%s %s %s\n",
899 oid_to_hex(&cmd
->old_oid
), oid_to_hex(&cmd
->new_oid
),
901 state
->cmd
= cmd
->next
;
904 *bufp
= state
->buf
.buf
;
905 *sizep
= state
->buf
.len
;
910 static int run_receive_hook(struct command
*commands
,
911 const char *hook_name
,
913 const struct string_list
*push_options
)
915 struct receive_hook_feed_state state
;
918 strbuf_init(&state
.buf
, 0);
919 state
.cmd
= commands
;
920 state
.skip_broken
= skip_broken
;
922 if (feed_receive_hook(&state
, NULL
, NULL
))
924 state
.cmd
= commands
;
925 state
.push_options
= push_options
;
926 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
927 strbuf_release(&state
.buf
);
931 static int run_update_hook(struct command
*cmd
)
933 struct child_process proc
= CHILD_PROCESS_INIT
;
935 const char *hook_path
= find_hook("update");
940 strvec_push(&proc
.args
, hook_path
);
941 strvec_push(&proc
.args
, cmd
->ref_name
);
942 strvec_push(&proc
.args
, oid_to_hex(&cmd
->old_oid
));
943 strvec_push(&proc
.args
, oid_to_hex(&cmd
->new_oid
));
946 proc
.stdout_to_stderr
= 1;
947 proc
.err
= use_sideband
? -1 : 0;
948 proc
.trace2_hook_name
= "update";
950 code
= start_command(&proc
);
954 copy_to_sideband(proc
.err
, -1, NULL
);
955 return finish_command(&proc
);
958 static struct command
*find_command_by_refname(struct command
*list
,
961 for (; list
; list
= list
->next
)
962 if (!strcmp(list
->ref_name
, refname
))
967 static int read_proc_receive_report(struct packet_reader
*reader
,
968 struct command
*commands
,
969 struct strbuf
*errmsg
)
972 struct command
*hint
= NULL
;
973 struct ref_push_report
*report
= NULL
;
980 struct object_id old_oid
, new_oid
;
984 enum packet_read_status status
;
986 status
= packet_reader_read(reader
);
987 if (status
!= PACKET_READ_NORMAL
) {
988 /* Check whether proc-receive exited abnormally */
989 if (status
== PACKET_READ_EOF
&& !response
) {
990 strbuf_addstr(errmsg
, "proc-receive exited abnormally");
998 p
= strchr(head
, ' ');
1000 strbuf_addf(errmsg
, "proc-receive reported incomplete status line: '%s'\n", head
);
1005 if (!strcmp(head
, "option")) {
1006 const char *key
, *val
;
1008 if (!hint
|| !(report
|| new_report
)) {
1010 strbuf_addstr(errmsg
, "proc-receive reported 'option' without a matching 'ok/ng' directive\n");
1015 if (!hint
->report
) {
1016 CALLOC_ARRAY(hint
->report
, 1);
1017 report
= hint
->report
;
1019 report
= hint
->report
;
1020 while (report
->next
)
1021 report
= report
->next
;
1022 report
->next
= xcalloc(1, sizeof(struct ref_push_report
));
1023 report
= report
->next
;
1028 p
= strchr(key
, ' ');
1032 if (!strcmp(key
, "refname"))
1033 report
->ref_name
= xstrdup_or_null(val
);
1034 else if (!strcmp(key
, "old-oid") && val
&&
1035 !parse_oid_hex(val
, &old_oid
, &val
))
1036 report
->old_oid
= oiddup(&old_oid
);
1037 else if (!strcmp(key
, "new-oid") && val
&&
1038 !parse_oid_hex(val
, &new_oid
, &val
))
1039 report
->new_oid
= oiddup(&new_oid
);
1040 else if (!strcmp(key
, "forced-update"))
1041 report
->forced_update
= 1;
1042 else if (!strcmp(key
, "fall-through"))
1043 /* Fall through, let 'receive-pack' to execute it. */
1044 hint
->run_proc_receive
= 0;
1051 p
= strchr(refname
, ' ');
1054 if (strcmp(head
, "ok") && strcmp(head
, "ng")) {
1055 strbuf_addf(errmsg
, "proc-receive reported bad status '%s' on ref '%s'\n",
1061 /* first try searching at our hint, falling back to all refs */
1063 hint
= find_command_by_refname(hint
, refname
);
1065 hint
= find_command_by_refname(commands
, refname
);
1067 strbuf_addf(errmsg
, "proc-receive reported status on unknown ref: %s\n",
1072 if (!hint
->run_proc_receive
) {
1073 strbuf_addf(errmsg
, "proc-receive reported status on unexpected ref: %s\n",
1078 hint
->run_proc_receive
|= RUN_PROC_RECEIVE_RETURNED
;
1079 if (!strcmp(head
, "ng")) {
1081 hint
->error_string
= xstrdup(p
);
1083 hint
->error_string
= "failed";
1090 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1091 if (cmd
->run_proc_receive
&& !cmd
->error_string
&&
1092 !(cmd
->run_proc_receive
& RUN_PROC_RECEIVE_RETURNED
)) {
1093 cmd
->error_string
= "proc-receive failed to report status";
1099 static int run_proc_receive_hook(struct command
*commands
,
1100 const struct string_list
*push_options
)
1102 struct child_process proc
= CHILD_PROCESS_INIT
;
1104 struct command
*cmd
;
1105 struct packet_reader reader
;
1106 struct strbuf cap
= STRBUF_INIT
;
1107 struct strbuf errmsg
= STRBUF_INIT
;
1108 int hook_use_push_options
= 0;
1111 const char *hook_path
= find_hook("proc-receive");
1114 rp_error("cannot find hook 'proc-receive'");
1118 strvec_push(&proc
.args
, hook_path
);
1121 proc
.trace2_hook_name
= "proc-receive";
1124 memset(&muxer
, 0, sizeof(muxer
));
1125 muxer
.proc
= copy_to_sideband
;
1127 code
= start_async(&muxer
);
1130 proc
.err
= muxer
.in
;
1135 code
= start_command(&proc
);
1138 finish_async(&muxer
);
1142 sigchain_push(SIGPIPE
, SIG_IGN
);
1144 /* Version negotiaton */
1145 packet_reader_init(&reader
, proc
.out
, NULL
, 0,
1146 PACKET_READ_CHOMP_NEWLINE
|
1147 PACKET_READ_GENTLE_ON_EOF
);
1149 strbuf_addstr(&cap
, " atomic");
1150 if (use_push_options
)
1151 strbuf_addstr(&cap
, " push-options");
1153 code
= packet_write_fmt_gently(proc
.in
, "version=1%c%s\n", '\0', cap
.buf
+ 1);
1154 strbuf_release(&cap
);
1156 code
= packet_write_fmt_gently(proc
.in
, "version=1\n");
1159 code
= packet_flush_gently(proc
.in
);
1164 enum packet_read_status status
;
1166 status
= packet_reader_read(&reader
);
1167 if (status
!= PACKET_READ_NORMAL
) {
1168 /* Check whether proc-receive exited abnormally */
1169 if (status
== PACKET_READ_EOF
)
1174 if (reader
.pktlen
> 8 && starts_with(reader
.line
, "version=")) {
1175 version
= atoi(reader
.line
+ 8);
1176 linelen
= strlen(reader
.line
);
1177 if (linelen
< reader
.pktlen
) {
1178 const char *feature_list
= reader
.line
+ linelen
+ 1;
1179 if (parse_feature_request(feature_list
, "push-options"))
1180 hook_use_push_options
= 1;
1186 strbuf_addstr(&errmsg
, "fail to negotiate version with proc-receive hook");
1196 strbuf_addf(&errmsg
, "proc-receive version '%d' is not supported",
1203 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1204 if (!cmd
->run_proc_receive
|| cmd
->skip_update
|| cmd
->error_string
)
1206 code
= packet_write_fmt_gently(proc
.in
, "%s %s %s",
1207 oid_to_hex(&cmd
->old_oid
),
1208 oid_to_hex(&cmd
->new_oid
),
1214 code
= packet_flush_gently(proc
.in
);
1216 strbuf_addstr(&errmsg
, "fail to write commands to proc-receive hook");
1220 /* Send push options */
1221 if (hook_use_push_options
) {
1222 struct string_list_item
*item
;
1224 for_each_string_list_item(item
, push_options
) {
1225 code
= packet_write_fmt_gently(proc
.in
, "%s", item
->string
);
1230 code
= packet_flush_gently(proc
.in
);
1232 strbuf_addstr(&errmsg
,
1233 "fail to write push-options to proc-receive hook");
1238 /* Read result from proc-receive */
1239 code
= read_proc_receive_report(&reader
, commands
, &errmsg
);
1245 finish_async(&muxer
);
1246 if (finish_command(&proc
))
1248 if (errmsg
.len
>0) {
1249 char *p
= errmsg
.buf
;
1251 p
+= errmsg
.len
- 1;
1254 rp_error("%s", errmsg
.buf
);
1255 strbuf_release(&errmsg
);
1257 sigchain_pop(SIGPIPE
);
1262 static char *refuse_unconfigured_deny_msg
=
1263 N_("By default, updating the current branch in a non-bare repository\n"
1264 "is denied, because it will make the index and work tree inconsistent\n"
1265 "with what you pushed, and will require 'git reset --hard' to match\n"
1266 "the work tree to HEAD.\n"
1268 "You can set the 'receive.denyCurrentBranch' configuration variable\n"
1269 "to 'ignore' or 'warn' in the remote repository to allow pushing into\n"
1270 "its current branch; however, this is not recommended unless you\n"
1271 "arranged to update its work tree to match what you pushed in some\n"
1274 "To squelch this message and still keep the default behaviour, set\n"
1275 "'receive.denyCurrentBranch' configuration variable to 'refuse'.");
1277 static void refuse_unconfigured_deny(void)
1279 rp_error("%s", _(refuse_unconfigured_deny_msg
));
1282 static char *refuse_unconfigured_deny_delete_current_msg
=
1283 N_("By default, deleting the current branch is denied, because the next\n"
1284 "'git clone' won't result in any file checked out, causing confusion.\n"
1286 "You can set 'receive.denyDeleteCurrent' configuration variable to\n"
1287 "'warn' or 'ignore' in the remote repository to allow deleting the\n"
1288 "current branch, with or without a warning message.\n"
1290 "To squelch this message, you can set it to 'refuse'.");
1292 static void refuse_unconfigured_deny_delete_current(void)
1294 rp_error("%s", _(refuse_unconfigured_deny_delete_current_msg
));
1297 static const struct object_id
*command_singleton_iterator(void *cb_data
);
1298 static int update_shallow_ref(struct command
*cmd
, struct shallow_info
*si
)
1300 struct shallow_lock shallow_lock
= SHALLOW_LOCK_INIT
;
1301 struct oid_array extra
= OID_ARRAY_INIT
;
1302 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1303 uint32_t mask
= 1 << (cmd
->index
% 32);
1306 trace_printf_key(&trace_shallow
,
1307 "shallow: update_shallow_ref %s\n", cmd
->ref_name
);
1308 for (i
= 0; i
< si
->shallow
->nr
; i
++)
1309 if (si
->used_shallow
[i
] &&
1310 (si
->used_shallow
[i
][cmd
->index
/ 32] & mask
) &&
1311 !delayed_reachability_test(si
, i
))
1312 oid_array_append(&extra
, &si
->shallow
->oid
[i
]);
1314 opt
.env
= tmp_objdir_env(tmp_objdir
);
1315 setup_alternate_shallow(&shallow_lock
, &opt
.shallow_file
, &extra
);
1316 if (check_connected(command_singleton_iterator
, cmd
, &opt
)) {
1317 rollback_shallow_file(the_repository
, &shallow_lock
);
1318 oid_array_clear(&extra
);
1322 commit_shallow_file(the_repository
, &shallow_lock
);
1325 * Make sure setup_alternate_shallow() for the next ref does
1326 * not lose these new roots..
1328 for (i
= 0; i
< extra
.nr
; i
++)
1329 register_shallow(the_repository
, &extra
.oid
[i
]);
1331 si
->shallow_ref
[cmd
->index
] = 0;
1332 oid_array_clear(&extra
);
1337 * NEEDSWORK: we should consolidate various implementions of "are we
1338 * on an unborn branch?" test into one, and make the unified one more
1339 * robust. !get_sha1() based check used here and elsewhere would not
1340 * allow us to tell an unborn branch from corrupt ref, for example.
1341 * For the purpose of fixing "deploy-to-update does not work when
1342 * pushing into an empty repository" issue, this should suffice for
1345 static int head_has_history(void)
1347 struct object_id oid
;
1349 return !get_oid("HEAD", &oid
);
1352 static const char *push_to_deploy(unsigned char *sha1
,
1354 const char *work_tree
)
1356 struct child_process child
= CHILD_PROCESS_INIT
;
1358 strvec_pushl(&child
.args
, "update-index", "-q", "--ignore-submodules",
1360 strvec_pushv(&child
.env_array
, env
->v
);
1361 child
.dir
= work_tree
;
1363 child
.stdout_to_stderr
= 1;
1365 if (run_command(&child
))
1366 return "Up-to-date check failed";
1368 /* run_command() does not clean up completely; reinitialize */
1369 child_process_init(&child
);
1370 strvec_pushl(&child
.args
, "diff-files", "--quiet",
1371 "--ignore-submodules", "--", NULL
);
1372 strvec_pushv(&child
.env_array
, env
->v
);
1373 child
.dir
= work_tree
;
1375 child
.stdout_to_stderr
= 1;
1377 if (run_command(&child
))
1378 return "Working directory has unstaged changes";
1380 child_process_init(&child
);
1381 strvec_pushl(&child
.args
, "diff-index", "--quiet", "--cached",
1382 "--ignore-submodules",
1383 /* diff-index with either HEAD or an empty tree */
1384 head_has_history() ? "HEAD" : empty_tree_oid_hex(),
1386 strvec_pushv(&child
.env_array
, env
->v
);
1388 child
.no_stdout
= 1;
1389 child
.stdout_to_stderr
= 0;
1391 if (run_command(&child
))
1392 return "Working directory has staged changes";
1394 child_process_init(&child
);
1395 strvec_pushl(&child
.args
, "read-tree", "-u", "-m", hash_to_hex(sha1
),
1397 strvec_pushv(&child
.env_array
, env
->v
);
1398 child
.dir
= work_tree
;
1400 child
.no_stdout
= 1;
1401 child
.stdout_to_stderr
= 0;
1403 if (run_command(&child
))
1404 return "Could not update working tree to new HEAD";
1409 static const char *push_to_checkout_hook
= "push-to-checkout";
1411 static const char *push_to_checkout(unsigned char *hash
,
1414 const char *work_tree
)
1416 struct run_hooks_opt opt
= RUN_HOOKS_OPT_INIT
;
1417 opt
.invoked_hook
= invoked_hook
;
1419 strvec_pushf(env
, "GIT_WORK_TREE=%s", absolute_path(work_tree
));
1420 strvec_pushv(&opt
.env
, env
->v
);
1421 strvec_push(&opt
.args
, hash_to_hex(hash
));
1422 if (run_hooks_opt(push_to_checkout_hook
, &opt
))
1423 return "push-to-checkout hook declined";
1428 static const char *update_worktree(unsigned char *sha1
, const struct worktree
*worktree
)
1430 const char *retval
, *git_dir
;
1431 struct strvec env
= STRVEC_INIT
;
1434 if (!worktree
|| !worktree
->path
)
1435 BUG("worktree->path must be non-NULL");
1437 if (worktree
->is_bare
)
1438 return "denyCurrentBranch = updateInstead needs a worktree";
1439 git_dir
= get_worktree_git_dir(worktree
);
1441 strvec_pushf(&env
, "GIT_DIR=%s", absolute_path(git_dir
));
1443 retval
= push_to_checkout(sha1
, &invoked_hook
, &env
, worktree
->path
);
1445 retval
= push_to_deploy(sha1
, &env
, worktree
->path
);
1451 static const char *update(struct command
*cmd
, struct shallow_info
*si
)
1453 const char *name
= cmd
->ref_name
;
1454 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
1455 static char *namespaced_name
;
1457 struct object_id
*old_oid
= &cmd
->old_oid
;
1458 struct object_id
*new_oid
= &cmd
->new_oid
;
1459 int do_update_worktree
= 0;
1460 struct worktree
**worktrees
= get_worktrees();
1461 const struct worktree
*worktree
=
1462 find_shared_symref(worktrees
, "HEAD", name
);
1464 /* only refs/... are allowed */
1465 if (!starts_with(name
, "refs/") || check_refname_format(name
+ 5, 0)) {
1466 rp_error("refusing to create funny ref '%s' remotely", name
);
1467 ret
= "funny refname";
1471 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
1472 free(namespaced_name
);
1473 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
1475 if (worktree
&& !worktree
->is_bare
) {
1476 switch (deny_current_branch
) {
1480 rp_warning("updating the current branch");
1483 case DENY_UNCONFIGURED
:
1484 rp_error("refusing to update checked out branch: %s", name
);
1485 if (deny_current_branch
== DENY_UNCONFIGURED
)
1486 refuse_unconfigured_deny();
1487 ret
= "branch is currently checked out";
1489 case DENY_UPDATE_INSTEAD
:
1490 /* pass -- let other checks intervene first */
1491 do_update_worktree
= 1;
1496 if (!is_null_oid(new_oid
) && !has_object_file(new_oid
)) {
1497 error("unpack should have generated %s, "
1498 "but I can't find it!", oid_to_hex(new_oid
));
1503 if (!is_null_oid(old_oid
) && is_null_oid(new_oid
)) {
1504 if (deny_deletes
&& starts_with(name
, "refs/heads/")) {
1505 rp_error("denying ref deletion for %s", name
);
1506 ret
= "deletion prohibited";
1510 if (worktree
|| (head_name
&& !strcmp(namespaced_name
, head_name
))) {
1511 switch (deny_delete_current
) {
1515 rp_warning("deleting the current branch");
1518 case DENY_UNCONFIGURED
:
1519 case DENY_UPDATE_INSTEAD
:
1520 if (deny_delete_current
== DENY_UNCONFIGURED
)
1521 refuse_unconfigured_deny_delete_current();
1522 rp_error("refusing to delete the current branch: %s", name
);
1523 ret
= "deletion of the current branch prohibited";
1526 ret
= "Invalid denyDeleteCurrent setting";
1532 if (deny_non_fast_forwards
&& !is_null_oid(new_oid
) &&
1533 !is_null_oid(old_oid
) &&
1534 starts_with(name
, "refs/heads/")) {
1535 struct object
*old_object
, *new_object
;
1536 struct commit
*old_commit
, *new_commit
;
1538 old_object
= parse_object(the_repository
, old_oid
);
1539 new_object
= parse_object(the_repository
, new_oid
);
1541 if (!old_object
|| !new_object
||
1542 old_object
->type
!= OBJ_COMMIT
||
1543 new_object
->type
!= OBJ_COMMIT
) {
1544 error("bad sha1 objects for %s", name
);
1548 old_commit
= (struct commit
*)old_object
;
1549 new_commit
= (struct commit
*)new_object
;
1550 if (!in_merge_bases(old_commit
, new_commit
)) {
1551 rp_error("denying non-fast-forward %s"
1552 " (you should pull first)", name
);
1553 ret
= "non-fast-forward";
1557 if (run_update_hook(cmd
)) {
1558 rp_error("hook declined to update %s", name
);
1559 ret
= "hook declined";
1563 if (do_update_worktree
) {
1564 ret
= update_worktree(new_oid
->hash
, worktree
);
1569 if (is_null_oid(new_oid
)) {
1570 struct strbuf err
= STRBUF_INIT
;
1571 if (!parse_object(the_repository
, old_oid
)) {
1573 if (ref_exists(name
)) {
1574 rp_warning("allowing deletion of corrupt ref");
1576 rp_warning("deleting a non-existent ref");
1577 cmd
->did_not_exist
= 1;
1580 if (ref_transaction_delete(transaction
,
1584 rp_error("%s", err
.buf
);
1585 ret
= "failed to delete";
1587 ret
= NULL
; /* good */
1589 strbuf_release(&err
);
1592 struct strbuf err
= STRBUF_INIT
;
1593 if (shallow_update
&& si
->shallow_ref
[cmd
->index
] &&
1594 update_shallow_ref(cmd
, si
)) {
1595 ret
= "shallow error";
1599 if (ref_transaction_update(transaction
,
1604 rp_error("%s", err
.buf
);
1605 ret
= "failed to update ref";
1607 ret
= NULL
; /* good */
1609 strbuf_release(&err
);
1613 free_worktrees(worktrees
);
1617 static void run_update_post_hook(struct command
*commands
)
1619 struct command
*cmd
;
1620 struct child_process proc
= CHILD_PROCESS_INIT
;
1623 hook
= find_hook("post-update");
1627 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1628 if (cmd
->error_string
|| cmd
->did_not_exist
)
1631 strvec_push(&proc
.args
, hook
);
1632 strvec_push(&proc
.args
, cmd
->ref_name
);
1638 proc
.stdout_to_stderr
= 1;
1639 proc
.err
= use_sideband
? -1 : 0;
1640 proc
.trace2_hook_name
= "post-update";
1642 if (!start_command(&proc
)) {
1644 copy_to_sideband(proc
.err
, -1, NULL
);
1645 finish_command(&proc
);
1649 static void check_aliased_update_internal(struct command
*cmd
,
1650 struct string_list
*list
,
1651 const char *dst_name
, int flag
)
1653 struct string_list_item
*item
;
1654 struct command
*dst_cmd
;
1656 if (!(flag
& REF_ISSYMREF
))
1660 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
1661 cmd
->skip_update
= 1;
1662 cmd
->error_string
= "broken symref";
1665 dst_name
= strip_namespace(dst_name
);
1667 if ((item
= string_list_lookup(list
, dst_name
)) == NULL
)
1670 cmd
->skip_update
= 1;
1672 dst_cmd
= (struct command
*) item
->util
;
1674 if (oideq(&cmd
->old_oid
, &dst_cmd
->old_oid
) &&
1675 oideq(&cmd
->new_oid
, &dst_cmd
->new_oid
))
1678 dst_cmd
->skip_update
= 1;
1680 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1681 " its target '%s' (%s..%s)",
1683 find_unique_abbrev(&cmd
->old_oid
, DEFAULT_ABBREV
),
1684 find_unique_abbrev(&cmd
->new_oid
, DEFAULT_ABBREV
),
1686 find_unique_abbrev(&dst_cmd
->old_oid
, DEFAULT_ABBREV
),
1687 find_unique_abbrev(&dst_cmd
->new_oid
, DEFAULT_ABBREV
));
1689 cmd
->error_string
= dst_cmd
->error_string
=
1690 "inconsistent aliased update";
1693 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
1695 struct strbuf buf
= STRBUF_INIT
;
1696 const char *dst_name
;
1699 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
1700 dst_name
= resolve_ref_unsafe(buf
.buf
, 0, NULL
, &flag
);
1701 check_aliased_update_internal(cmd
, list
, dst_name
, flag
);
1702 strbuf_release(&buf
);
1705 static void check_aliased_updates(struct command
*commands
)
1707 struct command
*cmd
;
1708 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
1710 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1711 struct string_list_item
*item
=
1712 string_list_append(&ref_list
, cmd
->ref_name
);
1713 item
->util
= (void *)cmd
;
1715 string_list_sort(&ref_list
);
1717 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1718 if (!cmd
->error_string
)
1719 check_aliased_update(cmd
, &ref_list
);
1722 string_list_clear(&ref_list
, 0);
1725 static const struct object_id
*command_singleton_iterator(void *cb_data
)
1727 struct command
**cmd_list
= cb_data
;
1728 struct command
*cmd
= *cmd_list
;
1730 if (!cmd
|| is_null_oid(&cmd
->new_oid
))
1732 *cmd_list
= NULL
; /* this returns only one */
1733 return &cmd
->new_oid
;
1736 static void set_connectivity_errors(struct command
*commands
,
1737 struct shallow_info
*si
)
1739 struct command
*cmd
;
1741 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1742 struct command
*singleton
= cmd
;
1743 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1745 if (shallow_update
&& si
->shallow_ref
[cmd
->index
])
1746 /* to be checked in update_shallow_ref() */
1749 opt
.env
= tmp_objdir_env(tmp_objdir
);
1750 if (!check_connected(command_singleton_iterator
, &singleton
,
1754 cmd
->error_string
= "missing necessary objects";
1758 struct iterate_data
{
1759 struct command
*cmds
;
1760 struct shallow_info
*si
;
1763 static const struct object_id
*iterate_receive_command_list(void *cb_data
)
1765 struct iterate_data
*data
= cb_data
;
1766 struct command
**cmd_list
= &data
->cmds
;
1767 struct command
*cmd
= *cmd_list
;
1769 for (; cmd
; cmd
= cmd
->next
) {
1770 if (shallow_update
&& data
->si
->shallow_ref
[cmd
->index
])
1771 /* to be checked in update_shallow_ref() */
1773 if (!is_null_oid(&cmd
->new_oid
) && !cmd
->skip_update
) {
1774 *cmd_list
= cmd
->next
;
1775 return &cmd
->new_oid
;
1781 static void reject_updates_to_hidden(struct command
*commands
)
1783 struct strbuf refname_full
= STRBUF_INIT
;
1785 struct command
*cmd
;
1787 strbuf_addstr(&refname_full
, get_git_namespace());
1788 prefix_len
= refname_full
.len
;
1790 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1791 if (cmd
->error_string
)
1794 strbuf_setlen(&refname_full
, prefix_len
);
1795 strbuf_addstr(&refname_full
, cmd
->ref_name
);
1797 if (!ref_is_hidden(cmd
->ref_name
, refname_full
.buf
))
1799 if (is_null_oid(&cmd
->new_oid
))
1800 cmd
->error_string
= "deny deleting a hidden ref";
1802 cmd
->error_string
= "deny updating a hidden ref";
1805 strbuf_release(&refname_full
);
1808 static int should_process_cmd(struct command
*cmd
)
1810 return !cmd
->error_string
&& !cmd
->skip_update
;
1813 static void warn_if_skipped_connectivity_check(struct command
*commands
,
1814 struct shallow_info
*si
)
1816 struct command
*cmd
;
1817 int checked_connectivity
= 1;
1819 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1820 if (should_process_cmd(cmd
) && si
->shallow_ref
[cmd
->index
]) {
1821 error("BUG: connectivity check has not been run on ref %s",
1823 checked_connectivity
= 0;
1826 if (!checked_connectivity
)
1827 BUG("connectivity check skipped???");
1830 static void execute_commands_non_atomic(struct command
*commands
,
1831 struct shallow_info
*si
)
1833 struct command
*cmd
;
1834 struct strbuf err
= STRBUF_INIT
;
1836 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1837 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1840 transaction
= ref_transaction_begin(&err
);
1842 rp_error("%s", err
.buf
);
1844 cmd
->error_string
= "transaction failed to start";
1848 cmd
->error_string
= update(cmd
, si
);
1850 if (!cmd
->error_string
1851 && ref_transaction_commit(transaction
, &err
)) {
1852 rp_error("%s", err
.buf
);
1854 cmd
->error_string
= "failed to update ref";
1856 ref_transaction_free(transaction
);
1858 strbuf_release(&err
);
1861 static void execute_commands_atomic(struct command
*commands
,
1862 struct shallow_info
*si
)
1864 struct command
*cmd
;
1865 struct strbuf err
= STRBUF_INIT
;
1866 const char *reported_error
= "atomic push failure";
1868 transaction
= ref_transaction_begin(&err
);
1870 rp_error("%s", err
.buf
);
1872 reported_error
= "transaction failed to start";
1876 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1877 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1880 cmd
->error_string
= update(cmd
, si
);
1882 if (cmd
->error_string
)
1886 if (ref_transaction_commit(transaction
, &err
)) {
1887 rp_error("%s", err
.buf
);
1888 reported_error
= "atomic transaction failed";
1894 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1895 if (!cmd
->error_string
)
1896 cmd
->error_string
= reported_error
;
1899 ref_transaction_free(transaction
);
1900 strbuf_release(&err
);
1903 static void execute_commands(struct command
*commands
,
1904 const char *unpacker_error
,
1905 struct shallow_info
*si
,
1906 const struct string_list
*push_options
)
1908 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1909 struct command
*cmd
;
1910 struct iterate_data data
;
1913 int run_proc_receive
= 0;
1915 if (unpacker_error
) {
1916 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1917 cmd
->error_string
= "unpacker error";
1922 memset(&muxer
, 0, sizeof(muxer
));
1923 muxer
.proc
= copy_to_sideband
;
1925 if (!start_async(&muxer
))
1927 /* ...else, continue without relaying sideband */
1930 data
.cmds
= commands
;
1932 opt
.err_fd
= err_fd
;
1933 opt
.progress
= err_fd
&& !quiet
;
1934 opt
.env
= tmp_objdir_env(tmp_objdir
);
1935 if (check_connected(iterate_receive_command_list
, &data
, &opt
))
1936 set_connectivity_errors(commands
, si
);
1939 finish_async(&muxer
);
1941 reject_updates_to_hidden(commands
);
1944 * Try to find commands that have special prefix in their reference names,
1945 * and mark them to run an external "proc-receive" hook later.
1947 if (proc_receive_ref
) {
1948 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1949 if (!should_process_cmd(cmd
))
1952 if (proc_receive_ref_matches(cmd
)) {
1953 cmd
->run_proc_receive
= RUN_PROC_RECEIVE_SCHEDULED
;
1954 run_proc_receive
= 1;
1959 if (run_receive_hook(commands
, "pre-receive", 0, push_options
)) {
1960 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1961 if (!cmd
->error_string
)
1962 cmd
->error_string
= "pre-receive hook declined";
1968 * If there is no command ready to run, should return directly to destroy
1969 * temporary data in the quarantine area.
1971 for (cmd
= commands
; cmd
&& cmd
->error_string
; cmd
= cmd
->next
)
1977 * Now we'll start writing out refs, which means the objects need
1978 * to be in their final positions so that other processes can see them.
1980 if (tmp_objdir_migrate(tmp_objdir
) < 0) {
1981 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1982 if (!cmd
->error_string
)
1983 cmd
->error_string
= "unable to migrate objects to permanent storage";
1989 check_aliased_updates(commands
);
1991 free(head_name_to_free
);
1992 head_name
= head_name_to_free
= resolve_refdup("HEAD", 0, NULL
, NULL
);
1994 if (run_proc_receive
&&
1995 run_proc_receive_hook(commands
, push_options
))
1996 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1997 if (!cmd
->error_string
&&
1998 !(cmd
->run_proc_receive
& RUN_PROC_RECEIVE_RETURNED
) &&
1999 (cmd
->run_proc_receive
|| use_atomic
))
2000 cmd
->error_string
= "fail to run proc-receive hook";
2003 execute_commands_atomic(commands
, si
);
2005 execute_commands_non_atomic(commands
, si
);
2008 warn_if_skipped_connectivity_check(commands
, si
);
2011 static struct command
**queue_command(struct command
**tail
,
2015 struct object_id old_oid
, new_oid
;
2016 struct command
*cmd
;
2017 const char *refname
;
2021 if (parse_oid_hex(line
, &old_oid
, &p
) ||
2023 parse_oid_hex(p
, &new_oid
, &p
) ||
2025 die("protocol error: expected old/new/ref, got '%s'", line
);
2028 reflen
= linelen
- (p
- line
);
2029 FLEX_ALLOC_MEM(cmd
, ref_name
, refname
, reflen
);
2030 oidcpy(&cmd
->old_oid
, &old_oid
);
2031 oidcpy(&cmd
->new_oid
, &new_oid
);
2036 static void queue_commands_from_cert(struct command
**tail
,
2037 struct strbuf
*push_cert
)
2039 const char *boc
, *eoc
;
2042 die("protocol error: got both push certificate and unsigned commands");
2044 boc
= strstr(push_cert
->buf
, "\n\n");
2046 die("malformed push certificate %.*s", 100, push_cert
->buf
);
2049 eoc
= push_cert
->buf
+ parse_signed_buffer(push_cert
->buf
, push_cert
->len
);
2052 const char *eol
= memchr(boc
, '\n', eoc
- boc
);
2053 tail
= queue_command(tail
, boc
, eol
? eol
- boc
: eoc
- boc
);
2054 boc
= eol
? eol
+ 1 : eoc
;
2058 static struct command
*read_head_info(struct packet_reader
*reader
,
2059 struct oid_array
*shallow
)
2061 struct command
*commands
= NULL
;
2062 struct command
**p
= &commands
;
2066 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
2069 if (reader
->pktlen
> 8 && starts_with(reader
->line
, "shallow ")) {
2070 struct object_id oid
;
2071 if (get_oid_hex(reader
->line
+ 8, &oid
))
2072 die("protocol error: expected shallow sha, got '%s'",
2074 oid_array_append(shallow
, &oid
);
2078 linelen
= strlen(reader
->line
);
2079 if (linelen
< reader
->pktlen
) {
2080 const char *feature_list
= reader
->line
+ linelen
+ 1;
2081 const char *hash
= NULL
;
2082 const char *client_sid
;
2084 if (parse_feature_request(feature_list
, "report-status"))
2086 if (parse_feature_request(feature_list
, "report-status-v2"))
2087 report_status_v2
= 1;
2088 if (parse_feature_request(feature_list
, "side-band-64k"))
2089 use_sideband
= LARGE_PACKET_MAX
;
2090 if (parse_feature_request(feature_list
, "quiet"))
2092 if (advertise_atomic_push
2093 && parse_feature_request(feature_list
, "atomic"))
2095 if (advertise_push_options
2096 && parse_feature_request(feature_list
, "push-options"))
2097 use_push_options
= 1;
2098 hash
= parse_feature_value(feature_list
, "object-format", &len
, NULL
);
2100 hash
= hash_algos
[GIT_HASH_SHA1
].name
;
2103 if (xstrncmpz(the_hash_algo
->name
, hash
, len
))
2104 die("error: unsupported object format '%s'", hash
);
2105 client_sid
= parse_feature_value(feature_list
, "session-id", &len
, NULL
);
2107 char *sid
= xstrndup(client_sid
, len
);
2108 trace2_data_string("transfer", NULL
, "client-sid", client_sid
);
2113 if (!strcmp(reader
->line
, "push-cert")) {
2115 int saved_options
= reader
->options
;
2116 reader
->options
&= ~PACKET_READ_CHOMP_NEWLINE
;
2119 packet_reader_read(reader
);
2120 if (reader
->status
== PACKET_READ_FLUSH
) {
2124 if (reader
->status
!= PACKET_READ_NORMAL
) {
2125 die("protocol error: got an unexpected packet");
2127 if (!strcmp(reader
->line
, "push-cert-end\n"))
2128 break; /* end of cert */
2129 strbuf_addstr(&push_cert
, reader
->line
);
2131 reader
->options
= saved_options
;
2138 p
= queue_command(p
, reader
->line
, linelen
);
2142 queue_commands_from_cert(p
, &push_cert
);
2147 static void read_push_options(struct packet_reader
*reader
,
2148 struct string_list
*options
)
2151 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
2154 string_list_append(options
, reader
->line
);
2158 static const char *parse_pack_header(struct pack_header
*hdr
)
2160 switch (read_pack_header(0, hdr
)) {
2162 return "eof before pack header was fully read";
2164 case PH_ERROR_PACK_SIGNATURE
:
2165 return "protocol error (pack signature mismatch detected)";
2167 case PH_ERROR_PROTOCOL
:
2168 return "protocol error (pack version unsupported)";
2171 return "unknown error in parse_pack_header";
2178 static const char *pack_lockfile
;
2180 static void push_header_arg(struct strvec
*args
, struct pack_header
*hdr
)
2182 strvec_pushf(args
, "--pack_header=%"PRIu32
",%"PRIu32
,
2183 ntohl(hdr
->hdr_version
), ntohl(hdr
->hdr_entries
));
2186 static const char *unpack(int err_fd
, struct shallow_info
*si
)
2188 struct pack_header hdr
;
2189 const char *hdr_err
;
2191 struct child_process child
= CHILD_PROCESS_INIT
;
2192 int fsck_objects
= (receive_fsck_objects
>= 0
2193 ? receive_fsck_objects
2194 : transfer_fsck_objects
>= 0
2195 ? transfer_fsck_objects
2198 hdr_err
= parse_pack_header(&hdr
);
2205 if (si
->nr_ours
|| si
->nr_theirs
) {
2206 alt_shallow_file
= setup_temporary_shallow(si
->shallow
);
2207 strvec_push(&child
.args
, "--shallow-file");
2208 strvec_push(&child
.args
, alt_shallow_file
);
2211 tmp_objdir
= tmp_objdir_create("incoming");
2215 return "unable to create temporary object directory";
2218 strvec_pushv(&child
.env_array
, tmp_objdir_env(tmp_objdir
));
2221 * Normally we just pass the tmp_objdir environment to the child
2222 * processes that do the heavy lifting, but we may need to see these
2223 * objects ourselves to set up shallow information.
2225 tmp_objdir_add_as_alternate(tmp_objdir
);
2227 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
2228 strvec_push(&child
.args
, "unpack-objects");
2229 push_header_arg(&child
.args
, &hdr
);
2231 strvec_push(&child
.args
, "-q");
2233 strvec_pushf(&child
.args
, "--strict%s",
2234 fsck_msg_types
.buf
);
2236 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2237 (uintmax_t)max_input_size
);
2238 child
.no_stdout
= 1;
2241 status
= run_command(&child
);
2243 return "unpack-objects abnormal exit";
2245 char hostname
[HOST_NAME_MAX
+ 1];
2247 strvec_pushl(&child
.args
, "index-pack", "--stdin", NULL
);
2248 push_header_arg(&child
.args
, &hdr
);
2250 if (xgethostname(hostname
, sizeof(hostname
)))
2251 xsnprintf(hostname
, sizeof(hostname
), "localhost");
2252 strvec_pushf(&child
.args
,
2253 "--keep=receive-pack %"PRIuMAX
" on %s",
2254 (uintmax_t)getpid(),
2257 if (!quiet
&& err_fd
)
2258 strvec_push(&child
.args
, "--show-resolving-progress");
2260 strvec_push(&child
.args
, "--report-end-of-input");
2262 strvec_pushf(&child
.args
, "--strict%s",
2263 fsck_msg_types
.buf
);
2265 strvec_push(&child
.args
, "--fix-thin");
2267 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2268 (uintmax_t)max_input_size
);
2272 status
= start_command(&child
);
2274 return "index-pack fork failed";
2275 pack_lockfile
= index_pack_lockfile(child
.out
, NULL
);
2277 status
= finish_command(&child
);
2279 return "index-pack abnormal exit";
2280 reprepare_packed_git(the_repository
);
2285 static const char *unpack_with_sideband(struct shallow_info
*si
)
2291 return unpack(0, si
);
2293 use_keepalive
= KEEPALIVE_AFTER_NUL
;
2294 memset(&muxer
, 0, sizeof(muxer
));
2295 muxer
.proc
= copy_to_sideband
;
2297 if (start_async(&muxer
))
2300 ret
= unpack(muxer
.in
, si
);
2302 finish_async(&muxer
);
2306 static void prepare_shallow_update(struct shallow_info
*si
)
2308 int i
, j
, k
, bitmap_size
= DIV_ROUND_UP(si
->ref
->nr
, 32);
2310 ALLOC_ARRAY(si
->used_shallow
, si
->shallow
->nr
);
2311 assign_shallow_commits_to_refs(si
, si
->used_shallow
, NULL
);
2313 CALLOC_ARRAY(si
->need_reachability_test
, si
->shallow
->nr
);
2314 CALLOC_ARRAY(si
->reachable
, si
->shallow
->nr
);
2315 CALLOC_ARRAY(si
->shallow_ref
, si
->ref
->nr
);
2317 for (i
= 0; i
< si
->nr_ours
; i
++)
2318 si
->need_reachability_test
[si
->ours
[i
]] = 1;
2320 for (i
= 0; i
< si
->shallow
->nr
; i
++) {
2321 if (!si
->used_shallow
[i
])
2323 for (j
= 0; j
< bitmap_size
; j
++) {
2324 if (!si
->used_shallow
[i
][j
])
2326 si
->need_reachability_test
[i
]++;
2327 for (k
= 0; k
< 32; k
++)
2328 if (si
->used_shallow
[i
][j
] & (1U << k
))
2329 si
->shallow_ref
[j
* 32 + k
]++;
2333 * true for those associated with some refs and belong
2334 * in "ours" list aka "step 7 not done yet"
2336 si
->need_reachability_test
[i
] =
2337 si
->need_reachability_test
[i
] > 1;
2341 * keep hooks happy by forcing a temporary shallow file via
2342 * env variable because we can't add --shallow-file to every
2343 * command. check_connected() will be done with
2344 * true .git/shallow though.
2346 setenv(GIT_SHALLOW_FILE_ENVIRONMENT
, alt_shallow_file
, 1);
2349 static void update_shallow_info(struct command
*commands
,
2350 struct shallow_info
*si
,
2351 struct oid_array
*ref
)
2353 struct command
*cmd
;
2355 remove_nonexistent_theirs_shallow(si
);
2356 if (!si
->nr_ours
&& !si
->nr_theirs
) {
2361 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2362 if (is_null_oid(&cmd
->new_oid
))
2364 oid_array_append(ref
, &cmd
->new_oid
);
2365 cmd
->index
= ref
->nr
- 1;
2369 if (shallow_update
) {
2370 prepare_shallow_update(si
);
2374 ALLOC_ARRAY(ref_status
, ref
->nr
);
2375 assign_shallow_commits_to_refs(si
, NULL
, ref_status
);
2376 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2377 if (is_null_oid(&cmd
->new_oid
))
2379 if (ref_status
[cmd
->index
]) {
2380 cmd
->error_string
= "shallow update not allowed";
2381 cmd
->skip_update
= 1;
2387 static void report(struct command
*commands
, const char *unpack_status
)
2389 struct command
*cmd
;
2390 struct strbuf buf
= STRBUF_INIT
;
2392 packet_buf_write(&buf
, "unpack %s\n",
2393 unpack_status
? unpack_status
: "ok");
2394 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2395 if (!cmd
->error_string
)
2396 packet_buf_write(&buf
, "ok %s\n",
2399 packet_buf_write(&buf
, "ng %s %s\n",
2400 cmd
->ref_name
, cmd
->error_string
);
2402 packet_buf_flush(&buf
);
2405 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2407 write_or_die(1, buf
.buf
, buf
.len
);
2408 strbuf_release(&buf
);
2411 static void report_v2(struct command
*commands
, const char *unpack_status
)
2413 struct command
*cmd
;
2414 struct strbuf buf
= STRBUF_INIT
;
2415 struct ref_push_report
*report
;
2417 packet_buf_write(&buf
, "unpack %s\n",
2418 unpack_status
? unpack_status
: "ok");
2419 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2422 if (cmd
->error_string
) {
2423 packet_buf_write(&buf
, "ng %s %s\n",
2428 packet_buf_write(&buf
, "ok %s\n",
2430 for (report
= cmd
->report
; report
; report
= report
->next
) {
2432 packet_buf_write(&buf
, "ok %s\n",
2434 if (report
->ref_name
)
2435 packet_buf_write(&buf
, "option refname %s\n",
2437 if (report
->old_oid
)
2438 packet_buf_write(&buf
, "option old-oid %s\n",
2439 oid_to_hex(report
->old_oid
));
2440 if (report
->new_oid
)
2441 packet_buf_write(&buf
, "option new-oid %s\n",
2442 oid_to_hex(report
->new_oid
));
2443 if (report
->forced_update
)
2444 packet_buf_write(&buf
, "option forced-update\n");
2447 packet_buf_flush(&buf
);
2450 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2452 write_or_die(1, buf
.buf
, buf
.len
);
2453 strbuf_release(&buf
);
2456 static int delete_only(struct command
*commands
)
2458 struct command
*cmd
;
2459 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2460 if (!is_null_oid(&cmd
->new_oid
))
2466 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
2468 int advertise_refs
= 0;
2469 struct command
*commands
;
2470 struct oid_array shallow
= OID_ARRAY_INIT
;
2471 struct oid_array ref
= OID_ARRAY_INIT
;
2472 struct shallow_info si
;
2473 struct packet_reader reader
;
2475 struct option options
[] = {
2476 OPT__QUIET(&quiet
, N_("quiet")),
2477 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc
, NULL
),
2478 OPT_HIDDEN_BOOL(0, "http-backend-info-refs", &advertise_refs
, NULL
),
2479 OPT_ALIAS(0, "advertise-refs", "http-backend-info-refs"),
2480 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin
, NULL
),
2484 packet_trace_identity("receive-pack");
2486 argc
= parse_options(argc
, argv
, prefix
, options
, receive_pack_usage
, 0);
2489 usage_msg_opt(_("too many arguments"), receive_pack_usage
, options
);
2491 usage_msg_opt(_("you must specify a directory"), receive_pack_usage
, options
);
2493 service_dir
= argv
[0];
2497 if (!enter_repo(service_dir
, 0))
2498 die("'%s' does not appear to be a git repository", service_dir
);
2500 git_config(receive_pack_config
, NULL
);
2501 if (cert_nonce_seed
)
2502 push_cert_nonce
= prepare_push_cert_nonce(service_dir
, time(NULL
));
2504 if (0 <= transfer_unpack_limit
)
2505 unpack_limit
= transfer_unpack_limit
;
2506 else if (0 <= receive_unpack_limit
)
2507 unpack_limit
= receive_unpack_limit
;
2509 switch (determine_protocol_version_server()) {
2512 * push support for protocol v2 has not been implemented yet,
2513 * so ignore the request to use v2 and fallback to using v0.
2518 * v1 is just the original protocol with a version string,
2519 * so just fall through after writing the version string.
2521 if (advertise_refs
|| !stateless_rpc
)
2522 packet_write_fmt(1, "version 1\n");
2527 case protocol_unknown_version
:
2528 BUG("unknown protocol version");
2531 if (advertise_refs
|| !stateless_rpc
) {
2537 packet_reader_init(&reader
, 0, NULL
, 0,
2538 PACKET_READ_CHOMP_NEWLINE
|
2539 PACKET_READ_DIE_ON_ERR_PACKET
);
2541 if ((commands
= read_head_info(&reader
, &shallow
)) != NULL
) {
2542 const char *unpack_status
= NULL
;
2543 struct string_list push_options
= STRING_LIST_INIT_DUP
;
2545 if (use_push_options
)
2546 read_push_options(&reader
, &push_options
);
2547 if (!check_cert_push_options(&push_options
)) {
2548 struct command
*cmd
;
2549 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
2550 cmd
->error_string
= "inconsistent push options";
2553 prepare_shallow_info(&si
, &shallow
);
2554 if (!si
.nr_ours
&& !si
.nr_theirs
)
2556 if (!delete_only(commands
)) {
2557 unpack_status
= unpack_with_sideband(&si
);
2558 update_shallow_info(commands
, &si
, &ref
);
2560 use_keepalive
= KEEPALIVE_ALWAYS
;
2561 execute_commands(commands
, unpack_status
, &si
,
2564 unlink_or_warn(pack_lockfile
);
2565 sigchain_push(SIGPIPE
, SIG_IGN
);
2566 if (report_status_v2
)
2567 report_v2(commands
, unpack_status
);
2568 else if (report_status
)
2569 report(commands
, unpack_status
);
2570 sigchain_pop(SIGPIPE
);
2571 run_receive_hook(commands
, "post-receive", 1,
2573 run_update_post_hook(commands
);
2574 string_list_clear(&push_options
, 0);
2576 struct child_process proc
= CHILD_PROCESS_INIT
;
2579 proc
.stdout_to_stderr
= 1;
2580 proc
.err
= use_sideband
? -1 : 0;
2581 proc
.git_cmd
= proc
.close_object_store
= 1;
2582 strvec_pushl(&proc
.args
, "gc", "--auto", "--quiet",
2585 if (!start_command(&proc
)) {
2587 copy_to_sideband(proc
.err
, -1, NULL
);
2588 finish_command(&proc
);
2591 if (auto_update_server_info
)
2592 update_server_info(0);
2593 clear_shallow_info(&si
);
2597 oid_array_clear(&shallow
);
2598 oid_array_clear(&ref
);
2599 free((void *)push_cert_nonce
);