3 #include "repository.h"
12 #include "run-command.h"
19 #include "string-list.h"
20 #include "oid-array.h"
21 #include "connected.h"
25 #include "gpg-interface.h"
28 #include "tmp-objdir.h"
31 #include "object-store.h"
33 #include "commit-reach.h"
37 static const char * const receive_pack_usage
[] = {
38 N_("git receive-pack <git-dir>"),
50 static int deny_deletes
;
51 static int deny_non_fast_forwards
;
52 static enum deny_action deny_current_branch
= DENY_UNCONFIGURED
;
53 static enum deny_action deny_delete_current
= DENY_UNCONFIGURED
;
54 static int receive_fsck_objects
= -1;
55 static int transfer_fsck_objects
= -1;
56 static struct strbuf fsck_msg_types
= STRBUF_INIT
;
57 static int receive_unpack_limit
= -1;
58 static int transfer_unpack_limit
= -1;
59 static int advertise_atomic_push
= 1;
60 static int advertise_push_options
;
61 static int advertise_sid
;
62 static int unpack_limit
= 100;
63 static off_t max_input_size
;
64 static int report_status
;
65 static int report_status_v2
;
66 static int use_sideband
;
67 static int use_atomic
;
68 static int use_push_options
;
70 static int prefer_ofs_delta
= 1;
71 static int auto_update_server_info
;
72 static int auto_gc
= 1;
73 static int reject_thin
;
74 static int stateless_rpc
;
75 static const char *service_dir
;
76 static const char *head_name
;
77 static void *head_name_to_free
;
78 static int sent_capabilities
;
79 static int shallow_update
;
80 static const char *alt_shallow_file
;
81 static struct strbuf push_cert
= STRBUF_INIT
;
82 static struct object_id push_cert_oid
;
83 static struct signature_check sigcheck
;
84 static const char *push_cert_nonce
;
85 static const char *cert_nonce_seed
;
86 static struct string_list hidden_refs
= STRING_LIST_INIT_DUP
;
88 static const char *NONCE_UNSOLICITED
= "UNSOLICITED";
89 static const char *NONCE_BAD
= "BAD";
90 static const char *NONCE_MISSING
= "MISSING";
91 static const char *NONCE_OK
= "OK";
92 static const char *NONCE_SLOP
= "SLOP";
93 static const char *nonce_status
;
94 static long nonce_stamp_slop
;
95 static timestamp_t nonce_stamp_slop_limit
;
96 static struct ref_transaction
*transaction
;
103 static int keepalive_in_sec
= 5;
105 static struct tmp_objdir
*tmp_objdir
;
107 static struct proc_receive_ref
{
108 unsigned int want_add
:1,
113 struct proc_receive_ref
*next
;
116 static void proc_receive_ref_append(const char *prefix
);
118 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
121 if (!strcasecmp(value
, "ignore"))
123 if (!strcasecmp(value
, "warn"))
125 if (!strcasecmp(value
, "refuse"))
127 if (!strcasecmp(value
, "updateinstead"))
128 return DENY_UPDATE_INSTEAD
;
130 if (git_config_bool(var
, value
))
135 static int receive_pack_config(const char *var
, const char *value
, void *cb
)
137 int status
= parse_hide_refs_config(var
, value
, "receive", &hidden_refs
);
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 UNUSED
, void *data
)
296 struct oidset
*seen
= data
;
297 const char *path
= strip_namespace(path_full
);
299 if (ref_is_hidden(path
, path_full
, &hidden_refs
))
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 UNUSED
, void *arg UNUSED
)
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
, "GIT_PUSH_CERT=%s",
768 oid_to_hex(&push_cert_oid
));
769 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT_SIGNER=%s",
770 sigcheck
.signer
? sigcheck
.signer
: "");
771 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT_KEY=%s",
772 sigcheck
.key
? sigcheck
.key
: "");
773 strvec_pushf(&proc
->env
, "GIT_PUSH_CERT_STATUS=%c",
775 if (push_cert_nonce
) {
776 strvec_pushf(&proc
->env
,
777 "GIT_PUSH_CERT_NONCE=%s",
779 strvec_pushf(&proc
->env
,
780 "GIT_PUSH_CERT_NONCE_STATUS=%s",
782 if (nonce_status
== NONCE_SLOP
)
783 strvec_pushf(&proc
->env
,
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
,
819 "GIT_PUSH_OPTION_%"PRIuMAX
"=%s",
821 feed_state
->push_options
->items
[i
].string
);
822 strvec_pushf(&proc
.env
, "GIT_PUSH_OPTION_COUNT=%"PRIuMAX
"",
823 (uintmax_t)feed_state
->push_options
->nr
);
825 strvec_pushf(&proc
.env
, "GIT_PUSH_OPTION_COUNT");
828 strvec_pushv(&proc
.env
, 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
, 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
, 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
, 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
, 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/") ||
1466 check_refname_format(name
+ 5, is_null_oid(new_oid
) ?
1467 REFNAME_ALLOW_ONELEVEL
: 0)) {
1468 rp_error("refusing to update funny ref '%s' remotely", name
);
1469 ret
= "funny refname";
1473 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
1474 free(namespaced_name
);
1475 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
1477 if (worktree
&& !worktree
->is_bare
) {
1478 switch (deny_current_branch
) {
1482 rp_warning("updating the current branch");
1485 case DENY_UNCONFIGURED
:
1486 rp_error("refusing to update checked out branch: %s", name
);
1487 if (deny_current_branch
== DENY_UNCONFIGURED
)
1488 refuse_unconfigured_deny();
1489 ret
= "branch is currently checked out";
1491 case DENY_UPDATE_INSTEAD
:
1492 /* pass -- let other checks intervene first */
1493 do_update_worktree
= 1;
1498 if (!is_null_oid(new_oid
) && !has_object_file(new_oid
)) {
1499 error("unpack should have generated %s, "
1500 "but I can't find it!", oid_to_hex(new_oid
));
1505 if (!is_null_oid(old_oid
) && is_null_oid(new_oid
)) {
1506 if (deny_deletes
&& starts_with(name
, "refs/heads/")) {
1507 rp_error("denying ref deletion for %s", name
);
1508 ret
= "deletion prohibited";
1512 if (worktree
|| (head_name
&& !strcmp(namespaced_name
, head_name
))) {
1513 switch (deny_delete_current
) {
1517 rp_warning("deleting the current branch");
1520 case DENY_UNCONFIGURED
:
1521 case DENY_UPDATE_INSTEAD
:
1522 if (deny_delete_current
== DENY_UNCONFIGURED
)
1523 refuse_unconfigured_deny_delete_current();
1524 rp_error("refusing to delete the current branch: %s", name
);
1525 ret
= "deletion of the current branch prohibited";
1528 ret
= "Invalid denyDeleteCurrent setting";
1534 if (deny_non_fast_forwards
&& !is_null_oid(new_oid
) &&
1535 !is_null_oid(old_oid
) &&
1536 starts_with(name
, "refs/heads/")) {
1537 struct object
*old_object
, *new_object
;
1538 struct commit
*old_commit
, *new_commit
;
1540 old_object
= parse_object(the_repository
, old_oid
);
1541 new_object
= parse_object(the_repository
, new_oid
);
1543 if (!old_object
|| !new_object
||
1544 old_object
->type
!= OBJ_COMMIT
||
1545 new_object
->type
!= OBJ_COMMIT
) {
1546 error("bad sha1 objects for %s", name
);
1550 old_commit
= (struct commit
*)old_object
;
1551 new_commit
= (struct commit
*)new_object
;
1552 if (!in_merge_bases(old_commit
, new_commit
)) {
1553 rp_error("denying non-fast-forward %s"
1554 " (you should pull first)", name
);
1555 ret
= "non-fast-forward";
1559 if (run_update_hook(cmd
)) {
1560 rp_error("hook declined to update %s", name
);
1561 ret
= "hook declined";
1565 if (do_update_worktree
) {
1566 ret
= update_worktree(new_oid
->hash
, worktree
);
1571 if (is_null_oid(new_oid
)) {
1572 struct strbuf err
= STRBUF_INIT
;
1573 if (!parse_object(the_repository
, old_oid
)) {
1575 if (ref_exists(name
)) {
1576 rp_warning("allowing deletion of corrupt ref");
1578 rp_warning("deleting a non-existent ref");
1579 cmd
->did_not_exist
= 1;
1582 if (ref_transaction_delete(transaction
,
1586 rp_error("%s", err
.buf
);
1587 ret
= "failed to delete";
1589 ret
= NULL
; /* good */
1591 strbuf_release(&err
);
1594 struct strbuf err
= STRBUF_INIT
;
1595 if (shallow_update
&& si
->shallow_ref
[cmd
->index
] &&
1596 update_shallow_ref(cmd
, si
)) {
1597 ret
= "shallow error";
1601 if (ref_transaction_update(transaction
,
1606 rp_error("%s", err
.buf
);
1607 ret
= "failed to update ref";
1609 ret
= NULL
; /* good */
1611 strbuf_release(&err
);
1615 free_worktrees(worktrees
);
1619 static void run_update_post_hook(struct command
*commands
)
1621 struct command
*cmd
;
1622 struct child_process proc
= CHILD_PROCESS_INIT
;
1625 hook
= find_hook("post-update");
1629 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1630 if (cmd
->error_string
|| cmd
->did_not_exist
)
1633 strvec_push(&proc
.args
, hook
);
1634 strvec_push(&proc
.args
, cmd
->ref_name
);
1640 proc
.stdout_to_stderr
= 1;
1641 proc
.err
= use_sideband
? -1 : 0;
1642 proc
.trace2_hook_name
= "post-update";
1644 if (!start_command(&proc
)) {
1646 copy_to_sideband(proc
.err
, -1, NULL
);
1647 finish_command(&proc
);
1651 static void check_aliased_update_internal(struct command
*cmd
,
1652 struct string_list
*list
,
1653 const char *dst_name
, int flag
)
1655 struct string_list_item
*item
;
1656 struct command
*dst_cmd
;
1658 if (!(flag
& REF_ISSYMREF
))
1662 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
1663 cmd
->skip_update
= 1;
1664 cmd
->error_string
= "broken symref";
1667 dst_name
= strip_namespace(dst_name
);
1669 if (!(item
= string_list_lookup(list
, dst_name
)))
1672 cmd
->skip_update
= 1;
1674 dst_cmd
= (struct command
*) item
->util
;
1676 if (oideq(&cmd
->old_oid
, &dst_cmd
->old_oid
) &&
1677 oideq(&cmd
->new_oid
, &dst_cmd
->new_oid
))
1680 dst_cmd
->skip_update
= 1;
1682 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1683 " its target '%s' (%s..%s)",
1685 find_unique_abbrev(&cmd
->old_oid
, DEFAULT_ABBREV
),
1686 find_unique_abbrev(&cmd
->new_oid
, DEFAULT_ABBREV
),
1688 find_unique_abbrev(&dst_cmd
->old_oid
, DEFAULT_ABBREV
),
1689 find_unique_abbrev(&dst_cmd
->new_oid
, DEFAULT_ABBREV
));
1691 cmd
->error_string
= dst_cmd
->error_string
=
1692 "inconsistent aliased update";
1695 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
1697 struct strbuf buf
= STRBUF_INIT
;
1698 const char *dst_name
;
1701 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
1702 dst_name
= resolve_ref_unsafe(buf
.buf
, 0, NULL
, &flag
);
1703 check_aliased_update_internal(cmd
, list
, dst_name
, flag
);
1704 strbuf_release(&buf
);
1707 static void check_aliased_updates(struct command
*commands
)
1709 struct command
*cmd
;
1710 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
1712 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1713 struct string_list_item
*item
=
1714 string_list_append(&ref_list
, cmd
->ref_name
);
1715 item
->util
= (void *)cmd
;
1717 string_list_sort(&ref_list
);
1719 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1720 if (!cmd
->error_string
)
1721 check_aliased_update(cmd
, &ref_list
);
1724 string_list_clear(&ref_list
, 0);
1727 static const struct object_id
*command_singleton_iterator(void *cb_data
)
1729 struct command
**cmd_list
= cb_data
;
1730 struct command
*cmd
= *cmd_list
;
1732 if (!cmd
|| is_null_oid(&cmd
->new_oid
))
1734 *cmd_list
= NULL
; /* this returns only one */
1735 return &cmd
->new_oid
;
1738 static void set_connectivity_errors(struct command
*commands
,
1739 struct shallow_info
*si
)
1741 struct command
*cmd
;
1743 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1744 struct command
*singleton
= cmd
;
1745 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1747 if (shallow_update
&& si
->shallow_ref
[cmd
->index
])
1748 /* to be checked in update_shallow_ref() */
1751 opt
.env
= tmp_objdir_env(tmp_objdir
);
1752 if (!check_connected(command_singleton_iterator
, &singleton
,
1756 cmd
->error_string
= "missing necessary objects";
1760 struct iterate_data
{
1761 struct command
*cmds
;
1762 struct shallow_info
*si
;
1765 static const struct object_id
*iterate_receive_command_list(void *cb_data
)
1767 struct iterate_data
*data
= cb_data
;
1768 struct command
**cmd_list
= &data
->cmds
;
1769 struct command
*cmd
= *cmd_list
;
1771 for (; cmd
; cmd
= cmd
->next
) {
1772 if (shallow_update
&& data
->si
->shallow_ref
[cmd
->index
])
1773 /* to be checked in update_shallow_ref() */
1775 if (!is_null_oid(&cmd
->new_oid
) && !cmd
->skip_update
) {
1776 *cmd_list
= cmd
->next
;
1777 return &cmd
->new_oid
;
1783 static void reject_updates_to_hidden(struct command
*commands
)
1785 struct strbuf refname_full
= STRBUF_INIT
;
1787 struct command
*cmd
;
1789 strbuf_addstr(&refname_full
, get_git_namespace());
1790 prefix_len
= refname_full
.len
;
1792 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1793 if (cmd
->error_string
)
1796 strbuf_setlen(&refname_full
, prefix_len
);
1797 strbuf_addstr(&refname_full
, cmd
->ref_name
);
1799 if (!ref_is_hidden(cmd
->ref_name
, refname_full
.buf
, &hidden_refs
))
1801 if (is_null_oid(&cmd
->new_oid
))
1802 cmd
->error_string
= "deny deleting a hidden ref";
1804 cmd
->error_string
= "deny updating a hidden ref";
1807 strbuf_release(&refname_full
);
1810 static int should_process_cmd(struct command
*cmd
)
1812 return !cmd
->error_string
&& !cmd
->skip_update
;
1815 static void BUG_if_skipped_connectivity_check(struct command
*commands
,
1816 struct shallow_info
*si
)
1818 struct command
*cmd
;
1820 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1821 if (should_process_cmd(cmd
) && si
->shallow_ref
[cmd
->index
])
1822 bug("connectivity check has not been run on ref %s",
1825 BUG_if_bug("connectivity check skipped???");
1828 static void execute_commands_non_atomic(struct command
*commands
,
1829 struct shallow_info
*si
)
1831 struct command
*cmd
;
1832 struct strbuf err
= STRBUF_INIT
;
1834 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1835 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1838 transaction
= ref_transaction_begin(&err
);
1840 rp_error("%s", err
.buf
);
1842 cmd
->error_string
= "transaction failed to start";
1846 cmd
->error_string
= update(cmd
, si
);
1848 if (!cmd
->error_string
1849 && ref_transaction_commit(transaction
, &err
)) {
1850 rp_error("%s", err
.buf
);
1852 cmd
->error_string
= "failed to update ref";
1854 ref_transaction_free(transaction
);
1856 strbuf_release(&err
);
1859 static void execute_commands_atomic(struct command
*commands
,
1860 struct shallow_info
*si
)
1862 struct command
*cmd
;
1863 struct strbuf err
= STRBUF_INIT
;
1864 const char *reported_error
= "atomic push failure";
1866 transaction
= ref_transaction_begin(&err
);
1868 rp_error("%s", err
.buf
);
1870 reported_error
= "transaction failed to start";
1874 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1875 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1878 cmd
->error_string
= update(cmd
, si
);
1880 if (cmd
->error_string
)
1884 if (ref_transaction_commit(transaction
, &err
)) {
1885 rp_error("%s", err
.buf
);
1886 reported_error
= "atomic transaction failed";
1892 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1893 if (!cmd
->error_string
)
1894 cmd
->error_string
= reported_error
;
1897 ref_transaction_free(transaction
);
1898 strbuf_release(&err
);
1901 static void execute_commands(struct command
*commands
,
1902 const char *unpacker_error
,
1903 struct shallow_info
*si
,
1904 const struct string_list
*push_options
)
1906 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1907 struct command
*cmd
;
1908 struct iterate_data data
;
1911 int run_proc_receive
= 0;
1913 if (unpacker_error
) {
1914 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1915 cmd
->error_string
= "unpacker error";
1920 memset(&muxer
, 0, sizeof(muxer
));
1921 muxer
.proc
= copy_to_sideband
;
1923 if (!start_async(&muxer
))
1925 /* ...else, continue without relaying sideband */
1928 data
.cmds
= commands
;
1930 opt
.err_fd
= err_fd
;
1931 opt
.progress
= err_fd
&& !quiet
;
1932 opt
.env
= tmp_objdir_env(tmp_objdir
);
1933 opt
.exclude_hidden_refs_section
= "receive";
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 BUG_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 free_commands(struct command
*commands
)
2039 struct command
*next
= commands
->next
;
2046 static void queue_commands_from_cert(struct command
**tail
,
2047 struct strbuf
*push_cert
)
2049 const char *boc
, *eoc
;
2052 die("protocol error: got both push certificate and unsigned commands");
2054 boc
= strstr(push_cert
->buf
, "\n\n");
2056 die("malformed push certificate %.*s", 100, push_cert
->buf
);
2059 eoc
= push_cert
->buf
+ parse_signed_buffer(push_cert
->buf
, push_cert
->len
);
2062 const char *eol
= memchr(boc
, '\n', eoc
- boc
);
2063 tail
= queue_command(tail
, boc
, eol
? eol
- boc
: eoc
- boc
);
2064 boc
= eol
? eol
+ 1 : eoc
;
2068 static struct command
*read_head_info(struct packet_reader
*reader
,
2069 struct oid_array
*shallow
)
2071 struct command
*commands
= NULL
;
2072 struct command
**p
= &commands
;
2076 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
2079 if (reader
->pktlen
> 8 && starts_with(reader
->line
, "shallow ")) {
2080 struct object_id oid
;
2081 if (get_oid_hex(reader
->line
+ 8, &oid
))
2082 die("protocol error: expected shallow sha, got '%s'",
2084 oid_array_append(shallow
, &oid
);
2088 linelen
= strlen(reader
->line
);
2089 if (linelen
< reader
->pktlen
) {
2090 const char *feature_list
= reader
->line
+ linelen
+ 1;
2091 const char *hash
= NULL
;
2092 const char *client_sid
;
2094 if (parse_feature_request(feature_list
, "report-status"))
2096 if (parse_feature_request(feature_list
, "report-status-v2"))
2097 report_status_v2
= 1;
2098 if (parse_feature_request(feature_list
, "side-band-64k"))
2099 use_sideband
= LARGE_PACKET_MAX
;
2100 if (parse_feature_request(feature_list
, "quiet"))
2102 if (advertise_atomic_push
2103 && parse_feature_request(feature_list
, "atomic"))
2105 if (advertise_push_options
2106 && parse_feature_request(feature_list
, "push-options"))
2107 use_push_options
= 1;
2108 hash
= parse_feature_value(feature_list
, "object-format", &len
, NULL
);
2110 hash
= hash_algos
[GIT_HASH_SHA1
].name
;
2113 if (xstrncmpz(the_hash_algo
->name
, hash
, len
))
2114 die("error: unsupported object format '%s'", hash
);
2115 client_sid
= parse_feature_value(feature_list
, "session-id", &len
, NULL
);
2117 char *sid
= xstrndup(client_sid
, len
);
2118 trace2_data_string("transfer", NULL
, "client-sid", client_sid
);
2123 if (!strcmp(reader
->line
, "push-cert")) {
2125 int saved_options
= reader
->options
;
2126 reader
->options
&= ~PACKET_READ_CHOMP_NEWLINE
;
2129 packet_reader_read(reader
);
2130 if (reader
->status
== PACKET_READ_FLUSH
) {
2134 if (reader
->status
!= PACKET_READ_NORMAL
) {
2135 die("protocol error: got an unexpected packet");
2137 if (!strcmp(reader
->line
, "push-cert-end\n"))
2138 break; /* end of cert */
2139 strbuf_addstr(&push_cert
, reader
->line
);
2141 reader
->options
= saved_options
;
2148 p
= queue_command(p
, reader
->line
, linelen
);
2152 queue_commands_from_cert(p
, &push_cert
);
2157 static void read_push_options(struct packet_reader
*reader
,
2158 struct string_list
*options
)
2161 if (packet_reader_read(reader
) != PACKET_READ_NORMAL
)
2164 string_list_append(options
, reader
->line
);
2168 static const char *parse_pack_header(struct pack_header
*hdr
)
2170 switch (read_pack_header(0, hdr
)) {
2172 return "eof before pack header was fully read";
2174 case PH_ERROR_PACK_SIGNATURE
:
2175 return "protocol error (pack signature mismatch detected)";
2177 case PH_ERROR_PROTOCOL
:
2178 return "protocol error (pack version unsupported)";
2181 return "unknown error in parse_pack_header";
2188 static const char *pack_lockfile
;
2190 static void push_header_arg(struct strvec
*args
, struct pack_header
*hdr
)
2192 strvec_pushf(args
, "--pack_header=%"PRIu32
",%"PRIu32
,
2193 ntohl(hdr
->hdr_version
), ntohl(hdr
->hdr_entries
));
2196 static const char *unpack(int err_fd
, struct shallow_info
*si
)
2198 struct pack_header hdr
;
2199 const char *hdr_err
;
2201 struct child_process child
= CHILD_PROCESS_INIT
;
2202 int fsck_objects
= (receive_fsck_objects
>= 0
2203 ? receive_fsck_objects
2204 : transfer_fsck_objects
>= 0
2205 ? transfer_fsck_objects
2208 hdr_err
= parse_pack_header(&hdr
);
2215 if (si
->nr_ours
|| si
->nr_theirs
) {
2216 alt_shallow_file
= setup_temporary_shallow(si
->shallow
);
2217 strvec_push(&child
.args
, "--shallow-file");
2218 strvec_push(&child
.args
, alt_shallow_file
);
2221 tmp_objdir
= tmp_objdir_create("incoming");
2225 return "unable to create temporary object directory";
2227 strvec_pushv(&child
.env
, tmp_objdir_env(tmp_objdir
));
2230 * Normally we just pass the tmp_objdir environment to the child
2231 * processes that do the heavy lifting, but we may need to see these
2232 * objects ourselves to set up shallow information.
2234 tmp_objdir_add_as_alternate(tmp_objdir
);
2236 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
2237 strvec_push(&child
.args
, "unpack-objects");
2238 push_header_arg(&child
.args
, &hdr
);
2240 strvec_push(&child
.args
, "-q");
2242 strvec_pushf(&child
.args
, "--strict%s",
2243 fsck_msg_types
.buf
);
2245 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2246 (uintmax_t)max_input_size
);
2247 child
.no_stdout
= 1;
2250 status
= run_command(&child
);
2252 return "unpack-objects abnormal exit";
2254 char hostname
[HOST_NAME_MAX
+ 1];
2256 strvec_pushl(&child
.args
, "index-pack", "--stdin", NULL
);
2257 push_header_arg(&child
.args
, &hdr
);
2259 if (xgethostname(hostname
, sizeof(hostname
)))
2260 xsnprintf(hostname
, sizeof(hostname
), "localhost");
2261 strvec_pushf(&child
.args
,
2262 "--keep=receive-pack %"PRIuMAX
" on %s",
2263 (uintmax_t)getpid(),
2266 if (!quiet
&& err_fd
)
2267 strvec_push(&child
.args
, "--show-resolving-progress");
2269 strvec_push(&child
.args
, "--report-end-of-input");
2271 strvec_pushf(&child
.args
, "--strict%s",
2272 fsck_msg_types
.buf
);
2274 strvec_push(&child
.args
, "--fix-thin");
2276 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2277 (uintmax_t)max_input_size
);
2281 status
= start_command(&child
);
2283 return "index-pack fork failed";
2284 pack_lockfile
= index_pack_lockfile(child
.out
, NULL
);
2286 status
= finish_command(&child
);
2288 return "index-pack abnormal exit";
2289 reprepare_packed_git(the_repository
);
2294 static const char *unpack_with_sideband(struct shallow_info
*si
)
2300 return unpack(0, si
);
2302 use_keepalive
= KEEPALIVE_AFTER_NUL
;
2303 memset(&muxer
, 0, sizeof(muxer
));
2304 muxer
.proc
= copy_to_sideband
;
2306 if (start_async(&muxer
))
2309 ret
= unpack(muxer
.in
, si
);
2311 finish_async(&muxer
);
2315 static void prepare_shallow_update(struct shallow_info
*si
)
2317 int i
, j
, k
, bitmap_size
= DIV_ROUND_UP(si
->ref
->nr
, 32);
2319 ALLOC_ARRAY(si
->used_shallow
, si
->shallow
->nr
);
2320 assign_shallow_commits_to_refs(si
, si
->used_shallow
, NULL
);
2322 CALLOC_ARRAY(si
->need_reachability_test
, si
->shallow
->nr
);
2323 CALLOC_ARRAY(si
->reachable
, si
->shallow
->nr
);
2324 CALLOC_ARRAY(si
->shallow_ref
, si
->ref
->nr
);
2326 for (i
= 0; i
< si
->nr_ours
; i
++)
2327 si
->need_reachability_test
[si
->ours
[i
]] = 1;
2329 for (i
= 0; i
< si
->shallow
->nr
; i
++) {
2330 if (!si
->used_shallow
[i
])
2332 for (j
= 0; j
< bitmap_size
; j
++) {
2333 if (!si
->used_shallow
[i
][j
])
2335 si
->need_reachability_test
[i
]++;
2336 for (k
= 0; k
< 32; k
++)
2337 if (si
->used_shallow
[i
][j
] & (1U << k
))
2338 si
->shallow_ref
[j
* 32 + k
]++;
2342 * true for those associated with some refs and belong
2343 * in "ours" list aka "step 7 not done yet"
2345 si
->need_reachability_test
[i
] =
2346 si
->need_reachability_test
[i
] > 1;
2350 * keep hooks happy by forcing a temporary shallow file via
2351 * env variable because we can't add --shallow-file to every
2352 * command. check_connected() will be done with
2353 * true .git/shallow though.
2355 setenv(GIT_SHALLOW_FILE_ENVIRONMENT
, alt_shallow_file
, 1);
2358 static void update_shallow_info(struct command
*commands
,
2359 struct shallow_info
*si
,
2360 struct oid_array
*ref
)
2362 struct command
*cmd
;
2364 remove_nonexistent_theirs_shallow(si
);
2365 if (!si
->nr_ours
&& !si
->nr_theirs
) {
2370 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2371 if (is_null_oid(&cmd
->new_oid
))
2373 oid_array_append(ref
, &cmd
->new_oid
);
2374 cmd
->index
= ref
->nr
- 1;
2378 if (shallow_update
) {
2379 prepare_shallow_update(si
);
2383 ALLOC_ARRAY(ref_status
, ref
->nr
);
2384 assign_shallow_commits_to_refs(si
, NULL
, ref_status
);
2385 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2386 if (is_null_oid(&cmd
->new_oid
))
2388 if (ref_status
[cmd
->index
]) {
2389 cmd
->error_string
= "shallow update not allowed";
2390 cmd
->skip_update
= 1;
2396 static void report(struct command
*commands
, const char *unpack_status
)
2398 struct command
*cmd
;
2399 struct strbuf buf
= STRBUF_INIT
;
2401 packet_buf_write(&buf
, "unpack %s\n",
2402 unpack_status
? unpack_status
: "ok");
2403 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2404 if (!cmd
->error_string
)
2405 packet_buf_write(&buf
, "ok %s\n",
2408 packet_buf_write(&buf
, "ng %s %s\n",
2409 cmd
->ref_name
, cmd
->error_string
);
2411 packet_buf_flush(&buf
);
2414 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2416 write_or_die(1, buf
.buf
, buf
.len
);
2417 strbuf_release(&buf
);
2420 static void report_v2(struct command
*commands
, const char *unpack_status
)
2422 struct command
*cmd
;
2423 struct strbuf buf
= STRBUF_INIT
;
2424 struct ref_push_report
*report
;
2426 packet_buf_write(&buf
, "unpack %s\n",
2427 unpack_status
? unpack_status
: "ok");
2428 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2431 if (cmd
->error_string
) {
2432 packet_buf_write(&buf
, "ng %s %s\n",
2437 packet_buf_write(&buf
, "ok %s\n",
2439 for (report
= cmd
->report
; report
; report
= report
->next
) {
2441 packet_buf_write(&buf
, "ok %s\n",
2443 if (report
->ref_name
)
2444 packet_buf_write(&buf
, "option refname %s\n",
2446 if (report
->old_oid
)
2447 packet_buf_write(&buf
, "option old-oid %s\n",
2448 oid_to_hex(report
->old_oid
));
2449 if (report
->new_oid
)
2450 packet_buf_write(&buf
, "option new-oid %s\n",
2451 oid_to_hex(report
->new_oid
));
2452 if (report
->forced_update
)
2453 packet_buf_write(&buf
, "option forced-update\n");
2456 packet_buf_flush(&buf
);
2459 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2461 write_or_die(1, buf
.buf
, buf
.len
);
2462 strbuf_release(&buf
);
2465 static int delete_only(struct command
*commands
)
2467 struct command
*cmd
;
2468 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2469 if (!is_null_oid(&cmd
->new_oid
))
2475 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
2477 int advertise_refs
= 0;
2478 struct command
*commands
;
2479 struct oid_array shallow
= OID_ARRAY_INIT
;
2480 struct oid_array ref
= OID_ARRAY_INIT
;
2481 struct shallow_info si
;
2482 struct packet_reader reader
;
2484 struct option options
[] = {
2485 OPT__QUIET(&quiet
, N_("quiet")),
2486 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc
, NULL
),
2487 OPT_HIDDEN_BOOL(0, "http-backend-info-refs", &advertise_refs
, NULL
),
2488 OPT_ALIAS(0, "advertise-refs", "http-backend-info-refs"),
2489 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin
, NULL
),
2493 packet_trace_identity("receive-pack");
2495 argc
= parse_options(argc
, argv
, prefix
, options
, receive_pack_usage
, 0);
2498 usage_msg_opt(_("too many arguments"), receive_pack_usage
, options
);
2500 usage_msg_opt(_("you must specify a directory"), receive_pack_usage
, options
);
2502 service_dir
= argv
[0];
2506 if (!enter_repo(service_dir
, 0))
2507 die("'%s' does not appear to be a git repository", service_dir
);
2509 git_config(receive_pack_config
, NULL
);
2510 if (cert_nonce_seed
)
2511 push_cert_nonce
= prepare_push_cert_nonce(service_dir
, time(NULL
));
2513 if (0 <= transfer_unpack_limit
)
2514 unpack_limit
= transfer_unpack_limit
;
2515 else if (0 <= receive_unpack_limit
)
2516 unpack_limit
= receive_unpack_limit
;
2518 switch (determine_protocol_version_server()) {
2521 * push support for protocol v2 has not been implemented yet,
2522 * so ignore the request to use v2 and fallback to using v0.
2527 * v1 is just the original protocol with a version string,
2528 * so just fall through after writing the version string.
2530 if (advertise_refs
|| !stateless_rpc
)
2531 packet_write_fmt(1, "version 1\n");
2536 case protocol_unknown_version
:
2537 BUG("unknown protocol version");
2540 if (advertise_refs
|| !stateless_rpc
) {
2546 packet_reader_init(&reader
, 0, NULL
, 0,
2547 PACKET_READ_CHOMP_NEWLINE
|
2548 PACKET_READ_DIE_ON_ERR_PACKET
);
2550 if ((commands
= read_head_info(&reader
, &shallow
))) {
2551 const char *unpack_status
= NULL
;
2552 struct string_list push_options
= STRING_LIST_INIT_DUP
;
2554 if (use_push_options
)
2555 read_push_options(&reader
, &push_options
);
2556 if (!check_cert_push_options(&push_options
)) {
2557 struct command
*cmd
;
2558 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
2559 cmd
->error_string
= "inconsistent push options";
2562 prepare_shallow_info(&si
, &shallow
);
2563 if (!si
.nr_ours
&& !si
.nr_theirs
)
2565 if (!delete_only(commands
)) {
2566 unpack_status
= unpack_with_sideband(&si
);
2567 update_shallow_info(commands
, &si
, &ref
);
2569 use_keepalive
= KEEPALIVE_ALWAYS
;
2570 execute_commands(commands
, unpack_status
, &si
,
2573 unlink_or_warn(pack_lockfile
);
2574 sigchain_push(SIGPIPE
, SIG_IGN
);
2575 if (report_status_v2
)
2576 report_v2(commands
, unpack_status
);
2577 else if (report_status
)
2578 report(commands
, unpack_status
);
2579 sigchain_pop(SIGPIPE
);
2580 run_receive_hook(commands
, "post-receive", 1,
2582 run_update_post_hook(commands
);
2583 free_commands(commands
);
2584 string_list_clear(&push_options
, 0);
2586 struct child_process proc
= CHILD_PROCESS_INIT
;
2589 proc
.stdout_to_stderr
= 1;
2590 proc
.err
= use_sideband
? -1 : 0;
2591 proc
.git_cmd
= proc
.close_object_store
= 1;
2592 strvec_pushl(&proc
.args
, "gc", "--auto", "--quiet",
2595 if (!start_command(&proc
)) {
2597 copy_to_sideband(proc
.err
, -1, NULL
);
2598 finish_command(&proc
);
2601 if (auto_update_server_info
)
2602 update_server_info(0);
2603 clear_shallow_info(&si
);
2607 oid_array_clear(&shallow
);
2608 oid_array_clear(&ref
);
2609 string_list_clear(&hidden_refs
, 0);
2610 free((void *)push_cert_nonce
);