2 #include "repository.h"
9 #include "run-command.h"
15 #include "string-list.h"
16 #include "oid-array.h"
17 #include "connected.h"
21 #include "gpg-interface.h"
24 #include "tmp-objdir.h"
27 #include "object-store.h"
29 #include "commit-reach.h"
33 static const char * const receive_pack_usage
[] = {
34 N_("git receive-pack <git-dir>"),
46 static int deny_deletes
;
47 static int deny_non_fast_forwards
;
48 static enum deny_action deny_current_branch
= DENY_UNCONFIGURED
;
49 static enum deny_action deny_delete_current
= DENY_UNCONFIGURED
;
50 static int receive_fsck_objects
= -1;
51 static int transfer_fsck_objects
= -1;
52 static struct strbuf fsck_msg_types
= STRBUF_INIT
;
53 static int receive_unpack_limit
= -1;
54 static int transfer_unpack_limit
= -1;
55 static int advertise_atomic_push
= 1;
56 static int advertise_push_options
;
57 static int advertise_sid
;
58 static int unpack_limit
= 100;
59 static off_t max_input_size
;
60 static int report_status
;
61 static int report_status_v2
;
62 static int use_sideband
;
63 static int use_atomic
;
64 static int use_push_options
;
66 static int prefer_ofs_delta
= 1;
67 static int auto_update_server_info
;
68 static int auto_gc
= 1;
69 static int reject_thin
;
70 static int stateless_rpc
;
71 static const char *service_dir
;
72 static const char *head_name
;
73 static void *head_name_to_free
;
74 static int sent_capabilities
;
75 static int shallow_update
;
76 static const char *alt_shallow_file
;
77 static struct strbuf push_cert
= STRBUF_INIT
;
78 static struct object_id push_cert_oid
;
79 static struct signature_check sigcheck
;
80 static const char *push_cert_nonce
;
81 static const char *cert_nonce_seed
;
83 static const char *NONCE_UNSOLICITED
= "UNSOLICITED";
84 static const char *NONCE_BAD
= "BAD";
85 static const char *NONCE_MISSING
= "MISSING";
86 static const char *NONCE_OK
= "OK";
87 static const char *NONCE_SLOP
= "SLOP";
88 static const char *nonce_status
;
89 static long nonce_stamp_slop
;
90 static timestamp_t nonce_stamp_slop_limit
;
91 static struct ref_transaction
*transaction
;
98 static int keepalive_in_sec
= 5;
100 static struct tmp_objdir
*tmp_objdir
;
102 static struct proc_receive_ref
{
103 unsigned int want_add
:1,
108 struct proc_receive_ref
*next
;
111 static void proc_receive_ref_append(const char *prefix
);
113 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
116 if (!strcasecmp(value
, "ignore"))
118 if (!strcasecmp(value
, "warn"))
120 if (!strcasecmp(value
, "refuse"))
122 if (!strcasecmp(value
, "updateinstead"))
123 return DENY_UPDATE_INSTEAD
;
125 if (git_config_bool(var
, value
))
130 static int receive_pack_config(const char *var
, const char *value
, void *cb
)
132 int status
= parse_hide_refs_config(var
, value
, "receive");
137 if (strcmp(var
, "receive.denydeletes") == 0) {
138 deny_deletes
= git_config_bool(var
, value
);
142 if (strcmp(var
, "receive.denynonfastforwards") == 0) {
143 deny_non_fast_forwards
= git_config_bool(var
, value
);
147 if (strcmp(var
, "receive.unpacklimit") == 0) {
148 receive_unpack_limit
= git_config_int(var
, value
);
152 if (strcmp(var
, "transfer.unpacklimit") == 0) {
153 transfer_unpack_limit
= git_config_int(var
, value
);
157 if (strcmp(var
, "receive.fsck.skiplist") == 0) {
160 if (git_config_pathname(&path
, var
, value
))
162 strbuf_addf(&fsck_msg_types
, "%cskiplist=%s",
163 fsck_msg_types
.len
? ',' : '=', path
);
168 if (skip_prefix(var
, "receive.fsck.", &var
)) {
169 if (is_valid_msg_type(var
, value
))
170 strbuf_addf(&fsck_msg_types
, "%c%s=%s",
171 fsck_msg_types
.len
? ',' : '=', var
, value
);
173 warning("Skipping unknown msg id '%s'", var
);
177 if (strcmp(var
, "receive.fsckobjects") == 0) {
178 receive_fsck_objects
= git_config_bool(var
, value
);
182 if (strcmp(var
, "transfer.fsckobjects") == 0) {
183 transfer_fsck_objects
= git_config_bool(var
, value
);
187 if (!strcmp(var
, "receive.denycurrentbranch")) {
188 deny_current_branch
= parse_deny_action(var
, value
);
192 if (strcmp(var
, "receive.denydeletecurrent") == 0) {
193 deny_delete_current
= parse_deny_action(var
, value
);
197 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
198 prefer_ofs_delta
= git_config_bool(var
, value
);
202 if (strcmp(var
, "receive.updateserverinfo") == 0) {
203 auto_update_server_info
= git_config_bool(var
, value
);
207 if (strcmp(var
, "receive.autogc") == 0) {
208 auto_gc
= git_config_bool(var
, value
);
212 if (strcmp(var
, "receive.shallowupdate") == 0) {
213 shallow_update
= git_config_bool(var
, value
);
217 if (strcmp(var
, "receive.certnonceseed") == 0)
218 return git_config_string(&cert_nonce_seed
, var
, value
);
220 if (strcmp(var
, "receive.certnonceslop") == 0) {
221 nonce_stamp_slop_limit
= git_config_ulong(var
, value
);
225 if (strcmp(var
, "receive.advertiseatomic") == 0) {
226 advertise_atomic_push
= git_config_bool(var
, value
);
230 if (strcmp(var
, "receive.advertisepushoptions") == 0) {
231 advertise_push_options
= git_config_bool(var
, value
);
235 if (strcmp(var
, "receive.keepalive") == 0) {
236 keepalive_in_sec
= git_config_int(var
, value
);
240 if (strcmp(var
, "receive.maxinputsize") == 0) {
241 max_input_size
= git_config_int64(var
, value
);
245 if (strcmp(var
, "receive.procreceiverefs") == 0) {
247 return config_error_nonbool(var
);
248 proc_receive_ref_append(value
);
252 if (strcmp(var
, "transfer.advertisesid") == 0) {
253 advertise_sid
= git_config_bool(var
, value
);
257 return git_default_config(var
, value
, cb
);
260 static void show_ref(const char *path
, const struct object_id
*oid
)
262 if (sent_capabilities
) {
263 packet_write_fmt(1, "%s %s\n", oid_to_hex(oid
), path
);
265 struct strbuf cap
= STRBUF_INIT
;
268 "report-status report-status-v2 delete-refs side-band-64k quiet");
269 if (advertise_atomic_push
)
270 strbuf_addstr(&cap
, " atomic");
271 if (prefer_ofs_delta
)
272 strbuf_addstr(&cap
, " ofs-delta");
274 strbuf_addf(&cap
, " push-cert=%s", push_cert_nonce
);
275 if (advertise_push_options
)
276 strbuf_addstr(&cap
, " push-options");
278 strbuf_addf(&cap
, " session-id=%s", trace2_session_id());
279 strbuf_addf(&cap
, " object-format=%s", the_hash_algo
->name
);
280 strbuf_addf(&cap
, " agent=%s", git_user_agent_sanitized());
281 packet_write_fmt(1, "%s %s%c%s\n",
282 oid_to_hex(oid
), path
, 0, cap
.buf
);
283 strbuf_release(&cap
);
284 sent_capabilities
= 1;
288 static int show_ref_cb(const char *path_full
, const struct object_id
*oid
,
289 int flag
, void *data
)
291 struct oidset
*seen
= data
;
292 const char *path
= strip_namespace(path_full
);
294 if (ref_is_hidden(path
, path_full
))
298 * Advertise refs outside our current namespace as ".have"
299 * refs, so that the client can use them to minimize data
300 * transfer but will otherwise ignore them.
303 if (oidset_insert(seen
, oid
))
307 oidset_insert(seen
, oid
);
313 static void show_one_alternate_ref(const struct object_id
*oid
,
316 struct oidset
*seen
= data
;
318 if (oidset_insert(seen
, oid
))
321 show_ref(".have", oid
);
324 static void write_head_info(void)
326 static struct oidset seen
= OIDSET_INIT
;
328 for_each_ref(show_ref_cb
, &seen
);
329 for_each_alternate_ref(show_one_alternate_ref
, &seen
);
331 if (!sent_capabilities
)
332 show_ref("capabilities^{}", null_oid());
334 advertise_shallow_grafts(1);
340 #define RUN_PROC_RECEIVE_SCHEDULED 1
341 #define RUN_PROC_RECEIVE_RETURNED 2
343 struct command
*next
;
344 const char *error_string
;
345 struct ref_push_report
*report
;
346 unsigned int skip_update
:1,
350 struct object_id old_oid
;
351 struct object_id new_oid
;
352 char ref_name
[FLEX_ARRAY
]; /* more */
355 static void proc_receive_ref_append(const char *prefix
)
357 struct proc_receive_ref
*ref_pattern
;
361 CALLOC_ARRAY(ref_pattern
, 1);
362 p
= strchr(prefix
, ':');
366 ref_pattern
->want_add
= 1;
367 else if (*prefix
== 'd')
368 ref_pattern
->want_delete
= 1;
369 else if (*prefix
== 'm')
370 ref_pattern
->want_modify
= 1;
371 else if (*prefix
== '!')
372 ref_pattern
->negative_ref
= 1;
377 ref_pattern
->want_add
= 1;
378 ref_pattern
->want_delete
= 1;
379 ref_pattern
->want_modify
= 1;
381 len
= strlen(prefix
);
382 while (len
&& prefix
[len
- 1] == '/')
384 ref_pattern
->ref_prefix
= xmemdupz(prefix
, len
);
385 if (!proc_receive_ref
) {
386 proc_receive_ref
= ref_pattern
;
388 struct proc_receive_ref
*end
;
390 end
= proc_receive_ref
;
393 end
->next
= ref_pattern
;
397 static int proc_receive_ref_matches(struct command
*cmd
)
399 struct proc_receive_ref
*p
;
401 if (!proc_receive_ref
)
404 for (p
= proc_receive_ref
; p
; p
= p
->next
) {
405 const char *match
= p
->ref_prefix
;
408 if (!p
->want_add
&& is_null_oid(&cmd
->old_oid
))
410 else if (!p
->want_delete
&& is_null_oid(&cmd
->new_oid
))
412 else if (!p
->want_modify
&&
413 !is_null_oid(&cmd
->old_oid
) &&
414 !is_null_oid(&cmd
->new_oid
))
417 if (skip_prefix(cmd
->ref_name
, match
, &remains
) &&
418 (!*remains
|| *remains
== '/')) {
419 if (!p
->negative_ref
)
421 } else if (p
->negative_ref
) {
428 static void report_message(const char *prefix
, const char *err
, va_list params
)
433 sz
= xsnprintf(msg
, sizeof(msg
), "%s", prefix
);
434 sz
+= vsnprintf(msg
+ sz
, sizeof(msg
) - sz
, err
, params
);
435 if (sz
> (sizeof(msg
) - 1))
436 sz
= sizeof(msg
) - 1;
440 send_sideband(1, 2, msg
, sz
, use_sideband
);
445 __attribute__((format (printf
, 1, 2)))
446 static void rp_warning(const char *err
, ...)
449 va_start(params
, err
);
450 report_message("warning: ", err
, params
);
454 __attribute__((format (printf
, 1, 2)))
455 static void rp_error(const char *err
, ...)
458 va_start(params
, err
);
459 report_message("error: ", err
, params
);
463 static int copy_to_sideband(int in
, int out
, void *arg
)
466 int keepalive_active
= 0;
468 if (keepalive_in_sec
<= 0)
469 use_keepalive
= KEEPALIVE_NEVER
;
470 if (use_keepalive
== KEEPALIVE_ALWAYS
)
471 keepalive_active
= 1;
476 if (keepalive_active
) {
482 ret
= poll(&pfd
, 1, 1000 * keepalive_in_sec
);
489 } else if (ret
== 0) {
490 /* no data; send a keepalive packet */
491 static const char buf
[] = "0005\1";
492 write_or_die(1, buf
, sizeof(buf
) - 1);
494 } /* else there is actual data to read */
497 sz
= xread(in
, data
, sizeof(data
));
501 if (use_keepalive
== KEEPALIVE_AFTER_NUL
&& !keepalive_active
) {
502 const char *p
= memchr(data
, '\0', sz
);
505 * The NUL tells us to start sending keepalives. Make
506 * sure we send any other data we read along
509 keepalive_active
= 1;
510 send_sideband(1, 2, data
, p
- data
, use_sideband
);
511 send_sideband(1, 2, p
+ 1, sz
- (p
- data
+ 1), use_sideband
);
517 * Either we're not looking for a NUL signal, or we didn't see
518 * it yet; just pass along the data.
520 send_sideband(1, 2, data
, sz
, use_sideband
);
526 static void hmac_hash(unsigned char *out
,
527 const char *key_in
, size_t key_len
,
528 const char *text
, size_t text_len
)
530 unsigned char key
[GIT_MAX_BLKSZ
];
531 unsigned char k_ipad
[GIT_MAX_BLKSZ
];
532 unsigned char k_opad
[GIT_MAX_BLKSZ
];
536 /* RFC 2104 2. (1) */
537 memset(key
, '\0', GIT_MAX_BLKSZ
);
538 if (the_hash_algo
->blksz
< key_len
) {
539 the_hash_algo
->init_fn(&ctx
);
540 the_hash_algo
->update_fn(&ctx
, key_in
, key_len
);
541 the_hash_algo
->final_fn(key
, &ctx
);
543 memcpy(key
, key_in
, key_len
);
546 /* RFC 2104 2. (2) & (5) */
547 for (i
= 0; i
< sizeof(key
); i
++) {
548 k_ipad
[i
] = key
[i
] ^ 0x36;
549 k_opad
[i
] = key
[i
] ^ 0x5c;
552 /* RFC 2104 2. (3) & (4) */
553 the_hash_algo
->init_fn(&ctx
);
554 the_hash_algo
->update_fn(&ctx
, k_ipad
, sizeof(k_ipad
));
555 the_hash_algo
->update_fn(&ctx
, text
, text_len
);
556 the_hash_algo
->final_fn(out
, &ctx
);
558 /* RFC 2104 2. (6) & (7) */
559 the_hash_algo
->init_fn(&ctx
);
560 the_hash_algo
->update_fn(&ctx
, k_opad
, sizeof(k_opad
));
561 the_hash_algo
->update_fn(&ctx
, out
, the_hash_algo
->rawsz
);
562 the_hash_algo
->final_fn(out
, &ctx
);
565 static char *prepare_push_cert_nonce(const char *path
, timestamp_t stamp
)
567 struct strbuf buf
= STRBUF_INIT
;
568 unsigned char hash
[GIT_MAX_RAWSZ
];
570 strbuf_addf(&buf
, "%s:%"PRItime
, path
, stamp
);
571 hmac_hash(hash
, buf
.buf
, buf
.len
, cert_nonce_seed
, strlen(cert_nonce_seed
));
572 strbuf_release(&buf
);
574 /* RFC 2104 5. HMAC-SHA1 or HMAC-SHA256 */
575 strbuf_addf(&buf
, "%"PRItime
"-%.*s", stamp
, (int)the_hash_algo
->hexsz
, hash_to_hex(hash
));
576 return strbuf_detach(&buf
, NULL
);
580 * NEEDSWORK: reuse find_commit_header() from jk/commit-author-parsing
581 * after dropping "_commit" from its name and possibly moving it out
584 static char *find_header(const char *msg
, size_t len
, const char *key
,
585 const char **next_line
)
587 int key_len
= strlen(key
);
588 const char *line
= msg
;
590 while (line
&& line
< msg
+ len
) {
591 const char *eol
= strchrnul(line
, '\n');
593 if ((msg
+ len
<= eol
) || line
== eol
)
595 if (line
+ key_len
< eol
&&
596 !memcmp(line
, key
, key_len
) && line
[key_len
] == ' ') {
597 int offset
= key_len
+ 1;
599 *next_line
= *eol
? eol
+ 1 : eol
;
600 return xmemdupz(line
+ offset
, (eol
- line
) - offset
);
602 line
= *eol
? eol
+ 1 : NULL
;
608 * Return zero if a and b are equal up to n bytes and nonzero if they are not.
609 * This operation is guaranteed to run in constant time to avoid leaking data.
611 static int constant_memequal(const char *a
, const char *b
, size_t n
)
616 for (i
= 0; i
< n
; i
++)
621 static const char *check_nonce(const char *buf
, size_t len
)
623 char *nonce
= find_header(buf
, len
, "nonce", NULL
);
624 timestamp_t stamp
, ostamp
;
625 char *bohmac
, *expect
= NULL
;
626 const char *retval
= NONCE_BAD
;
630 retval
= NONCE_MISSING
;
632 } else if (!push_cert_nonce
) {
633 retval
= NONCE_UNSOLICITED
;
635 } else if (!strcmp(push_cert_nonce
, nonce
)) {
640 if (!stateless_rpc
) {
641 /* returned nonce MUST match what we gave out earlier */
647 * In stateless mode, we may be receiving a nonce issued by
648 * another instance of the server that serving the same
649 * repository, and the timestamps may not match, but the
650 * nonce-seed and dir should match, so we can recompute and
651 * report the time slop.
653 * In addition, when a nonce issued by another instance has
654 * timestamp within receive.certnonceslop seconds, we pretend
655 * as if we issued that nonce when reporting to the hook.
658 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
659 if (*nonce
<= '0' || '9' < *nonce
) {
663 stamp
= parse_timestamp(nonce
, &bohmac
, 10);
664 if (bohmac
== nonce
|| bohmac
[0] != '-') {
669 noncelen
= strlen(nonce
);
670 expect
= prepare_push_cert_nonce(service_dir
, stamp
);
671 if (noncelen
!= strlen(expect
)) {
672 /* This is not even the right size. */
676 if (constant_memequal(expect
, nonce
, noncelen
)) {
677 /* Not what we would have signed earlier */
683 * By how many seconds is this nonce stale? Negative value
684 * would mean it was issued by another server with its clock
685 * skewed in the future.
687 ostamp
= parse_timestamp(push_cert_nonce
, NULL
, 10);
688 nonce_stamp_slop
= (long)ostamp
- (long)stamp
;
690 if (nonce_stamp_slop_limit
&&
691 labs(nonce_stamp_slop
) <= nonce_stamp_slop_limit
) {
693 * Pretend as if the received nonce (which passes the
694 * HMAC check, so it is not a forged by third-party)
697 free((void *)push_cert_nonce
);
698 push_cert_nonce
= xstrdup(nonce
);
711 * Return 1 if there is no push_cert or if the push options in push_cert are
712 * the same as those in the argument; 0 otherwise.
714 static int check_cert_push_options(const struct string_list
*push_options
)
716 const char *buf
= push_cert
.buf
;
717 int len
= push_cert
.len
;
720 const char *next_line
;
721 int options_seen
= 0;
728 while ((option
= find_header(buf
, len
, "push-option", &next_line
))) {
729 len
-= (next_line
- buf
);
732 if (options_seen
> push_options
->nr
734 push_options
->items
[options_seen
- 1].string
)) {
741 if (options_seen
!= push_options
->nr
)
749 static void prepare_push_cert_sha1(struct child_process
*proc
)
751 static int already_done
;
757 int bogs
/* beginning_of_gpg_sig */;
760 if (write_object_file(push_cert
.buf
, push_cert
.len
, "blob",
762 oidclr(&push_cert_oid
);
764 memset(&sigcheck
, '\0', sizeof(sigcheck
));
766 bogs
= parse_signed_buffer(push_cert
.buf
, push_cert
.len
);
767 check_signature(push_cert
.buf
, bogs
, push_cert
.buf
+ bogs
,
768 push_cert
.len
- bogs
, &sigcheck
);
770 nonce_status
= check_nonce(push_cert
.buf
, bogs
);
772 if (!is_null_oid(&push_cert_oid
)) {
773 strvec_pushf(&proc
->env_array
, "GIT_PUSH_CERT=%s",
774 oid_to_hex(&push_cert_oid
));
775 strvec_pushf(&proc
->env_array
, "GIT_PUSH_CERT_SIGNER=%s",
776 sigcheck
.signer
? sigcheck
.signer
: "");
777 strvec_pushf(&proc
->env_array
, "GIT_PUSH_CERT_KEY=%s",
778 sigcheck
.key
? sigcheck
.key
: "");
779 strvec_pushf(&proc
->env_array
, "GIT_PUSH_CERT_STATUS=%c",
781 if (push_cert_nonce
) {
782 strvec_pushf(&proc
->env_array
,
783 "GIT_PUSH_CERT_NONCE=%s",
785 strvec_pushf(&proc
->env_array
,
786 "GIT_PUSH_CERT_NONCE_STATUS=%s",
788 if (nonce_status
== NONCE_SLOP
)
789 strvec_pushf(&proc
->env_array
,
790 "GIT_PUSH_CERT_NONCE_SLOP=%ld",
796 struct receive_hook_feed_state
{
798 struct ref_push_report
*report
;
801 const struct string_list
*push_options
;
804 typedef int (*feed_fn
)(void *, const char **, size_t *);
805 static int run_and_feed_hook(const char *hook_name
, feed_fn feed
,
806 struct receive_hook_feed_state
*feed_state
)
808 struct child_process proc
= CHILD_PROCESS_INIT
;
813 argv
[0] = find_hook(hook_name
);
821 proc
.stdout_to_stderr
= 1;
822 proc
.trace2_hook_name
= hook_name
;
824 if (feed_state
->push_options
) {
826 for (i
= 0; i
< feed_state
->push_options
->nr
; i
++)
827 strvec_pushf(&proc
.env_array
,
828 "GIT_PUSH_OPTION_%d=%s", i
,
829 feed_state
->push_options
->items
[i
].string
);
830 strvec_pushf(&proc
.env_array
, "GIT_PUSH_OPTION_COUNT=%d",
831 feed_state
->push_options
->nr
);
833 strvec_pushf(&proc
.env_array
, "GIT_PUSH_OPTION_COUNT");
836 strvec_pushv(&proc
.env_array
, tmp_objdir_env(tmp_objdir
));
839 memset(&muxer
, 0, sizeof(muxer
));
840 muxer
.proc
= copy_to_sideband
;
842 code
= start_async(&muxer
);
848 prepare_push_cert_sha1(&proc
);
850 code
= start_command(&proc
);
853 finish_async(&muxer
);
857 sigchain_push(SIGPIPE
, SIG_IGN
);
862 if (feed(feed_state
, &buf
, &n
))
864 if (write_in_full(proc
.in
, buf
, n
) < 0)
869 finish_async(&muxer
);
871 sigchain_pop(SIGPIPE
);
873 return finish_command(&proc
);
876 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
878 struct receive_hook_feed_state
*state
= state_
;
879 struct command
*cmd
= state
->cmd
;
882 state
->skip_broken
&& (cmd
->error_string
|| cmd
->did_not_exist
))
887 return 0; /* OK, can feed something. */
888 strbuf_reset(&state
->buf
);
890 state
->report
= cmd
->report
;
892 struct object_id
*old_oid
;
893 struct object_id
*new_oid
;
894 const char *ref_name
;
896 old_oid
= state
->report
->old_oid
? state
->report
->old_oid
: &cmd
->old_oid
;
897 new_oid
= state
->report
->new_oid
? state
->report
->new_oid
: &cmd
->new_oid
;
898 ref_name
= state
->report
->ref_name
? state
->report
->ref_name
: cmd
->ref_name
;
899 strbuf_addf(&state
->buf
, "%s %s %s\n",
900 oid_to_hex(old_oid
), oid_to_hex(new_oid
),
902 state
->report
= state
->report
->next
;
904 state
->cmd
= cmd
->next
;
906 strbuf_addf(&state
->buf
, "%s %s %s\n",
907 oid_to_hex(&cmd
->old_oid
), oid_to_hex(&cmd
->new_oid
),
909 state
->cmd
= cmd
->next
;
912 *bufp
= state
->buf
.buf
;
913 *sizep
= state
->buf
.len
;
918 static int run_receive_hook(struct command
*commands
,
919 const char *hook_name
,
921 const struct string_list
*push_options
)
923 struct receive_hook_feed_state state
;
926 strbuf_init(&state
.buf
, 0);
927 state
.cmd
= commands
;
928 state
.skip_broken
= skip_broken
;
930 if (feed_receive_hook(&state
, NULL
, NULL
))
932 state
.cmd
= commands
;
933 state
.push_options
= push_options
;
934 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
935 strbuf_release(&state
.buf
);
939 static int run_update_hook(struct command
*cmd
)
942 struct child_process proc
= CHILD_PROCESS_INIT
;
945 argv
[0] = find_hook("update");
949 argv
[1] = cmd
->ref_name
;
950 argv
[2] = oid_to_hex(&cmd
->old_oid
);
951 argv
[3] = oid_to_hex(&cmd
->new_oid
);
955 proc
.stdout_to_stderr
= 1;
956 proc
.err
= use_sideband
? -1 : 0;
958 proc
.trace2_hook_name
= "update";
960 code
= start_command(&proc
);
964 copy_to_sideband(proc
.err
, -1, NULL
);
965 return finish_command(&proc
);
968 static struct command
*find_command_by_refname(struct command
*list
,
971 for (; list
; list
= list
->next
)
972 if (!strcmp(list
->ref_name
, refname
))
977 static int read_proc_receive_report(struct packet_reader
*reader
,
978 struct command
*commands
,
979 struct strbuf
*errmsg
)
982 struct command
*hint
= NULL
;
983 struct ref_push_report
*report
= NULL
;
990 struct object_id old_oid
, new_oid
;
994 enum packet_read_status status
;
996 status
= packet_reader_read(reader
);
997 if (status
!= PACKET_READ_NORMAL
) {
998 /* Check whether proc-receive exited abnormally */
999 if (status
== PACKET_READ_EOF
&& !response
) {
1000 strbuf_addstr(errmsg
, "proc-receive exited abnormally");
1007 head
= reader
->line
;
1008 p
= strchr(head
, ' ');
1010 strbuf_addf(errmsg
, "proc-receive reported incomplete status line: '%s'\n", head
);
1015 if (!strcmp(head
, "option")) {
1016 const char *key
, *val
;
1018 if (!hint
|| !(report
|| new_report
)) {
1020 strbuf_addstr(errmsg
, "proc-receive reported 'option' without a matching 'ok/ng' directive\n");
1025 if (!hint
->report
) {
1026 CALLOC_ARRAY(hint
->report
, 1);
1027 report
= hint
->report
;
1029 report
= hint
->report
;
1030 while (report
->next
)
1031 report
= report
->next
;
1032 report
->next
= xcalloc(1, sizeof(struct ref_push_report
));
1033 report
= report
->next
;
1038 p
= strchr(key
, ' ');
1042 if (!strcmp(key
, "refname"))
1043 report
->ref_name
= xstrdup_or_null(val
);
1044 else if (!strcmp(key
, "old-oid") && val
&&
1045 !parse_oid_hex(val
, &old_oid
, &val
))
1046 report
->old_oid
= oiddup(&old_oid
);
1047 else if (!strcmp(key
, "new-oid") && val
&&
1048 !parse_oid_hex(val
, &new_oid
, &val
))
1049 report
->new_oid
= oiddup(&new_oid
);
1050 else if (!strcmp(key
, "forced-update"))
1051 report
->forced_update
= 1;
1052 else if (!strcmp(key
, "fall-through"))
1053 /* Fall through, let 'receive-pack' to execute it. */
1054 hint
->run_proc_receive
= 0;
1061 p
= strchr(refname
, ' ');
1064 if (strcmp(head
, "ok") && strcmp(head
, "ng")) {
1065 strbuf_addf(errmsg
, "proc-receive reported bad status '%s' on ref '%s'\n",
1071 /* first try searching at our hint, falling back to all refs */
1073 hint
= find_command_by_refname(hint
, refname
);
1075 hint
= find_command_by_refname(commands
, refname
);
1077 strbuf_addf(errmsg
, "proc-receive reported status on unknown ref: %s\n",
1082 if (!hint
->run_proc_receive
) {
1083 strbuf_addf(errmsg
, "proc-receive reported status on unexpected ref: %s\n",
1088 hint
->run_proc_receive
|= RUN_PROC_RECEIVE_RETURNED
;
1089 if (!strcmp(head
, "ng")) {
1091 hint
->error_string
= xstrdup(p
);
1093 hint
->error_string
= "failed";
1100 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1101 if (cmd
->run_proc_receive
&& !cmd
->error_string
&&
1102 !(cmd
->run_proc_receive
& RUN_PROC_RECEIVE_RETURNED
)) {
1103 cmd
->error_string
= "proc-receive failed to report status";
1109 static int run_proc_receive_hook(struct command
*commands
,
1110 const struct string_list
*push_options
)
1112 struct child_process proc
= CHILD_PROCESS_INIT
;
1114 struct command
*cmd
;
1115 const char *argv
[2];
1116 struct packet_reader reader
;
1117 struct strbuf cap
= STRBUF_INIT
;
1118 struct strbuf errmsg
= STRBUF_INIT
;
1119 int hook_use_push_options
= 0;
1123 argv
[0] = find_hook("proc-receive");
1125 rp_error("cannot find hook 'proc-receive'");
1133 proc
.trace2_hook_name
= "proc-receive";
1136 memset(&muxer
, 0, sizeof(muxer
));
1137 muxer
.proc
= copy_to_sideband
;
1139 code
= start_async(&muxer
);
1142 proc
.err
= muxer
.in
;
1147 code
= start_command(&proc
);
1150 finish_async(&muxer
);
1154 sigchain_push(SIGPIPE
, SIG_IGN
);
1156 /* Version negotiaton */
1157 packet_reader_init(&reader
, proc
.out
, NULL
, 0,
1158 PACKET_READ_CHOMP_NEWLINE
|
1159 PACKET_READ_GENTLE_ON_EOF
);
1161 strbuf_addstr(&cap
, " atomic");
1162 if (use_push_options
)
1163 strbuf_addstr(&cap
, " push-options");
1165 code
= packet_write_fmt_gently(proc
.in
, "version=1%c%s\n", '\0', cap
.buf
+ 1);
1166 strbuf_release(&cap
);
1168 code
= packet_write_fmt_gently(proc
.in
, "version=1\n");
1171 code
= packet_flush_gently(proc
.in
);
1176 enum packet_read_status status
;
1178 status
= packet_reader_read(&reader
);
1179 if (status
!= PACKET_READ_NORMAL
) {
1180 /* Check whether proc-receive exited abnormally */
1181 if (status
== PACKET_READ_EOF
)
1186 if (reader
.pktlen
> 8 && starts_with(reader
.line
, "version=")) {
1187 version
= atoi(reader
.line
+ 8);
1188 linelen
= strlen(reader
.line
);
1189 if (linelen
< reader
.pktlen
) {
1190 const char *feature_list
= reader
.line
+ linelen
+ 1;
1191 if (parse_feature_request(feature_list
, "push-options"))
1192 hook_use_push_options
= 1;
1198 strbuf_addstr(&errmsg
, "fail to negotiate version with proc-receive hook");
1208 strbuf_addf(&errmsg
, "proc-receive version '%d' is not supported",
1215 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1216 if (!cmd
->run_proc_receive
|| cmd
->skip_update
|| cmd
->error_string
)
1218 code
= packet_write_fmt_gently(proc
.in
, "%s %s %s",
1219 oid_to_hex(&cmd
->old_oid
),
1220 oid_to_hex(&cmd
->new_oid
),
1226 code
= packet_flush_gently(proc
.in
);
1228 strbuf_addstr(&errmsg
, "fail to write commands to proc-receive hook");
1232 /* Send push options */
1233 if (hook_use_push_options
) {
1234 struct string_list_item
*item
;
1236 for_each_string_list_item(item
, push_options
) {
1237 code
= packet_write_fmt_gently(proc
.in
, "%s", item
->string
);
1242 code
= packet_flush_gently(proc
.in
);
1244 strbuf_addstr(&errmsg
,
1245 "fail to write push-options to proc-receive hook");
1250 /* Read result from proc-receive */
1251 code
= read_proc_receive_report(&reader
, commands
, &errmsg
);
1257 finish_async(&muxer
);
1258 if (finish_command(&proc
))
1260 if (errmsg
.len
>0) {
1261 char *p
= errmsg
.buf
;
1263 p
+= errmsg
.len
- 1;
1266 rp_error("%s", errmsg
.buf
);
1267 strbuf_release(&errmsg
);
1269 sigchain_pop(SIGPIPE
);
1274 static char *refuse_unconfigured_deny_msg
=
1275 N_("By default, updating the current branch in a non-bare repository\n"
1276 "is denied, because it will make the index and work tree inconsistent\n"
1277 "with what you pushed, and will require 'git reset --hard' to match\n"
1278 "the work tree to HEAD.\n"
1280 "You can set the 'receive.denyCurrentBranch' configuration variable\n"
1281 "to 'ignore' or 'warn' in the remote repository to allow pushing into\n"
1282 "its current branch; however, this is not recommended unless you\n"
1283 "arranged to update its work tree to match what you pushed in some\n"
1286 "To squelch this message and still keep the default behaviour, set\n"
1287 "'receive.denyCurrentBranch' configuration variable to 'refuse'.");
1289 static void refuse_unconfigured_deny(void)
1291 rp_error("%s", _(refuse_unconfigured_deny_msg
));
1294 static char *refuse_unconfigured_deny_delete_current_msg
=
1295 N_("By default, deleting the current branch is denied, because the next\n"
1296 "'git clone' won't result in any file checked out, causing confusion.\n"
1298 "You can set 'receive.denyDeleteCurrent' configuration variable to\n"
1299 "'warn' or 'ignore' in the remote repository to allow deleting the\n"
1300 "current branch, with or without a warning message.\n"
1302 "To squelch this message, you can set it to 'refuse'.");
1304 static void refuse_unconfigured_deny_delete_current(void)
1306 rp_error("%s", _(refuse_unconfigured_deny_delete_current_msg
));
1309 static const struct object_id
*command_singleton_iterator(void *cb_data
);
1310 static int update_shallow_ref(struct command
*cmd
, struct shallow_info
*si
)
1312 struct shallow_lock shallow_lock
= SHALLOW_LOCK_INIT
;
1313 struct oid_array extra
= OID_ARRAY_INIT
;
1314 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1315 uint32_t mask
= 1 << (cmd
->index
% 32);
1318 trace_printf_key(&trace_shallow
,
1319 "shallow: update_shallow_ref %s\n", cmd
->ref_name
);
1320 for (i
= 0; i
< si
->shallow
->nr
; i
++)
1321 if (si
->used_shallow
[i
] &&
1322 (si
->used_shallow
[i
][cmd
->index
/ 32] & mask
) &&
1323 !delayed_reachability_test(si
, i
))
1324 oid_array_append(&extra
, &si
->shallow
->oid
[i
]);
1326 opt
.env
= tmp_objdir_env(tmp_objdir
);
1327 setup_alternate_shallow(&shallow_lock
, &opt
.shallow_file
, &extra
);
1328 if (check_connected(command_singleton_iterator
, cmd
, &opt
)) {
1329 rollback_shallow_file(the_repository
, &shallow_lock
);
1330 oid_array_clear(&extra
);
1334 commit_shallow_file(the_repository
, &shallow_lock
);
1337 * Make sure setup_alternate_shallow() for the next ref does
1338 * not lose these new roots..
1340 for (i
= 0; i
< extra
.nr
; i
++)
1341 register_shallow(the_repository
, &extra
.oid
[i
]);
1343 si
->shallow_ref
[cmd
->index
] = 0;
1344 oid_array_clear(&extra
);
1349 * NEEDSWORK: we should consolidate various implementions of "are we
1350 * on an unborn branch?" test into one, and make the unified one more
1351 * robust. !get_sha1() based check used here and elsewhere would not
1352 * allow us to tell an unborn branch from corrupt ref, for example.
1353 * For the purpose of fixing "deploy-to-update does not work when
1354 * pushing into an empty repository" issue, this should suffice for
1357 static int head_has_history(void)
1359 struct object_id oid
;
1361 return !get_oid("HEAD", &oid
);
1364 static const char *push_to_deploy(unsigned char *sha1
,
1366 const char *work_tree
)
1368 const char *update_refresh
[] = {
1369 "update-index", "-q", "--ignore-submodules", "--refresh", NULL
1371 const char *diff_files
[] = {
1372 "diff-files", "--quiet", "--ignore-submodules", "--", NULL
1374 const char *diff_index
[] = {
1375 "diff-index", "--quiet", "--cached", "--ignore-submodules",
1378 const char *read_tree
[] = {
1379 "read-tree", "-u", "-m", NULL
, NULL
1381 struct child_process child
= CHILD_PROCESS_INIT
;
1383 child
.argv
= update_refresh
;
1385 child
.dir
= work_tree
;
1387 child
.stdout_to_stderr
= 1;
1389 if (run_command(&child
))
1390 return "Up-to-date check failed";
1392 /* run_command() does not clean up completely; reinitialize */
1393 child_process_init(&child
);
1394 child
.argv
= diff_files
;
1396 child
.dir
= work_tree
;
1398 child
.stdout_to_stderr
= 1;
1400 if (run_command(&child
))
1401 return "Working directory has unstaged changes";
1403 /* diff-index with either HEAD or an empty tree */
1404 diff_index
[4] = head_has_history() ? "HEAD" : empty_tree_oid_hex();
1406 child_process_init(&child
);
1407 child
.argv
= diff_index
;
1410 child
.no_stdout
= 1;
1411 child
.stdout_to_stderr
= 0;
1413 if (run_command(&child
))
1414 return "Working directory has staged changes";
1416 read_tree
[3] = hash_to_hex(sha1
);
1417 child_process_init(&child
);
1418 child
.argv
= read_tree
;
1420 child
.dir
= work_tree
;
1422 child
.no_stdout
= 1;
1423 child
.stdout_to_stderr
= 0;
1425 if (run_command(&child
))
1426 return "Could not update working tree to new HEAD";
1431 static const char *push_to_checkout_hook
= "push-to-checkout";
1433 static const char *push_to_checkout(unsigned char *hash
,
1435 const char *work_tree
)
1437 strvec_pushf(env
, "GIT_WORK_TREE=%s", absolute_path(work_tree
));
1438 if (run_hook_le(env
->v
, push_to_checkout_hook
,
1439 hash_to_hex(hash
), NULL
))
1440 return "push-to-checkout hook declined";
1445 static const char *update_worktree(unsigned char *sha1
, const struct worktree
*worktree
)
1447 const char *retval
, *work_tree
, *git_dir
= NULL
;
1448 struct strvec env
= STRVEC_INIT
;
1450 if (worktree
&& worktree
->path
)
1451 work_tree
= worktree
->path
;
1452 else if (git_work_tree_cfg
)
1453 work_tree
= git_work_tree_cfg
;
1457 if (is_bare_repository())
1458 return "denyCurrentBranch = updateInstead needs a worktree";
1460 git_dir
= get_worktree_git_dir(worktree
);
1462 git_dir
= get_git_dir();
1464 strvec_pushf(&env
, "GIT_DIR=%s", absolute_path(git_dir
));
1466 if (!find_hook(push_to_checkout_hook
))
1467 retval
= push_to_deploy(sha1
, &env
, work_tree
);
1469 retval
= push_to_checkout(sha1
, &env
, work_tree
);
1475 static const char *update(struct command
*cmd
, struct shallow_info
*si
)
1477 const char *name
= cmd
->ref_name
;
1478 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
1479 static char *namespaced_name
;
1481 struct object_id
*old_oid
= &cmd
->old_oid
;
1482 struct object_id
*new_oid
= &cmd
->new_oid
;
1483 int do_update_worktree
= 0;
1484 const struct worktree
*worktree
= is_bare_repository() ? NULL
: find_shared_symref("HEAD", name
);
1486 /* only refs/... are allowed */
1487 if (!starts_with(name
, "refs/") || check_refname_format(name
+ 5, 0)) {
1488 rp_error("refusing to create funny ref '%s' remotely", name
);
1489 return "funny refname";
1492 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
1493 free(namespaced_name
);
1494 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
1497 switch (deny_current_branch
) {
1501 rp_warning("updating the current branch");
1504 case DENY_UNCONFIGURED
:
1505 rp_error("refusing to update checked out branch: %s", name
);
1506 if (deny_current_branch
== DENY_UNCONFIGURED
)
1507 refuse_unconfigured_deny();
1508 return "branch is currently checked out";
1509 case DENY_UPDATE_INSTEAD
:
1510 /* pass -- let other checks intervene first */
1511 do_update_worktree
= 1;
1516 if (!is_null_oid(new_oid
) && !has_object_file(new_oid
)) {
1517 error("unpack should have generated %s, "
1518 "but I can't find it!", oid_to_hex(new_oid
));
1522 if (!is_null_oid(old_oid
) && is_null_oid(new_oid
)) {
1523 if (deny_deletes
&& starts_with(name
, "refs/heads/")) {
1524 rp_error("denying ref deletion for %s", name
);
1525 return "deletion prohibited";
1528 if (worktree
|| (head_name
&& !strcmp(namespaced_name
, head_name
))) {
1529 switch (deny_delete_current
) {
1533 rp_warning("deleting the current branch");
1536 case DENY_UNCONFIGURED
:
1537 case DENY_UPDATE_INSTEAD
:
1538 if (deny_delete_current
== DENY_UNCONFIGURED
)
1539 refuse_unconfigured_deny_delete_current();
1540 rp_error("refusing to delete the current branch: %s", name
);
1541 return "deletion of the current branch prohibited";
1543 return "Invalid denyDeleteCurrent setting";
1548 if (deny_non_fast_forwards
&& !is_null_oid(new_oid
) &&
1549 !is_null_oid(old_oid
) &&
1550 starts_with(name
, "refs/heads/")) {
1551 struct object
*old_object
, *new_object
;
1552 struct commit
*old_commit
, *new_commit
;
1554 old_object
= parse_object(the_repository
, old_oid
);
1555 new_object
= parse_object(the_repository
, new_oid
);
1557 if (!old_object
|| !new_object
||
1558 old_object
->type
!= OBJ_COMMIT
||
1559 new_object
->type
!= OBJ_COMMIT
) {
1560 error("bad sha1 objects for %s", name
);
1563 old_commit
= (struct commit
*)old_object
;
1564 new_commit
= (struct commit
*)new_object
;
1565 if (!in_merge_bases(old_commit
, new_commit
)) {
1566 rp_error("denying non-fast-forward %s"
1567 " (you should pull first)", name
);
1568 return "non-fast-forward";
1571 if (run_update_hook(cmd
)) {
1572 rp_error("hook declined to update %s", name
);
1573 return "hook declined";
1576 if (do_update_worktree
) {
1577 ret
= update_worktree(new_oid
->hash
, find_shared_symref("HEAD", name
));
1582 if (is_null_oid(new_oid
)) {
1583 struct strbuf err
= STRBUF_INIT
;
1584 if (!parse_object(the_repository
, old_oid
)) {
1586 if (ref_exists(name
)) {
1587 rp_warning("Allowing deletion of corrupt ref.");
1589 rp_warning("Deleting a non-existent ref.");
1590 cmd
->did_not_exist
= 1;
1593 if (ref_transaction_delete(transaction
,
1597 rp_error("%s", err
.buf
);
1598 strbuf_release(&err
);
1599 return "failed to delete";
1601 strbuf_release(&err
);
1602 return NULL
; /* good */
1605 struct strbuf err
= STRBUF_INIT
;
1606 if (shallow_update
&& si
->shallow_ref
[cmd
->index
] &&
1607 update_shallow_ref(cmd
, si
))
1608 return "shallow error";
1610 if (ref_transaction_update(transaction
,
1615 rp_error("%s", err
.buf
);
1616 strbuf_release(&err
);
1618 return "failed to update ref";
1620 strbuf_release(&err
);
1622 return NULL
; /* good */
1626 static void run_update_post_hook(struct command
*commands
)
1628 struct command
*cmd
;
1629 struct child_process proc
= CHILD_PROCESS_INIT
;
1632 hook
= find_hook("post-update");
1636 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1637 if (cmd
->error_string
|| cmd
->did_not_exist
)
1640 strvec_push(&proc
.args
, hook
);
1641 strvec_push(&proc
.args
, cmd
->ref_name
);
1647 proc
.stdout_to_stderr
= 1;
1648 proc
.err
= use_sideband
? -1 : 0;
1649 proc
.trace2_hook_name
= "post-update";
1651 if (!start_command(&proc
)) {
1653 copy_to_sideband(proc
.err
, -1, NULL
);
1654 finish_command(&proc
);
1658 static void check_aliased_update_internal(struct command
*cmd
,
1659 struct string_list
*list
,
1660 const char *dst_name
, int flag
)
1662 struct string_list_item
*item
;
1663 struct command
*dst_cmd
;
1665 if (!(flag
& REF_ISSYMREF
))
1669 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
1670 cmd
->skip_update
= 1;
1671 cmd
->error_string
= "broken symref";
1674 dst_name
= strip_namespace(dst_name
);
1676 if ((item
= string_list_lookup(list
, dst_name
)) == NULL
)
1679 cmd
->skip_update
= 1;
1681 dst_cmd
= (struct command
*) item
->util
;
1683 if (oideq(&cmd
->old_oid
, &dst_cmd
->old_oid
) &&
1684 oideq(&cmd
->new_oid
, &dst_cmd
->new_oid
))
1687 dst_cmd
->skip_update
= 1;
1689 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1690 " its target '%s' (%s..%s)",
1692 find_unique_abbrev(&cmd
->old_oid
, DEFAULT_ABBREV
),
1693 find_unique_abbrev(&cmd
->new_oid
, DEFAULT_ABBREV
),
1695 find_unique_abbrev(&dst_cmd
->old_oid
, DEFAULT_ABBREV
),
1696 find_unique_abbrev(&dst_cmd
->new_oid
, DEFAULT_ABBREV
));
1698 cmd
->error_string
= dst_cmd
->error_string
=
1699 "inconsistent aliased update";
1702 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
1704 struct strbuf buf
= STRBUF_INIT
;
1705 const char *dst_name
;
1708 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
1709 dst_name
= resolve_ref_unsafe(buf
.buf
, 0, NULL
, &flag
);
1710 check_aliased_update_internal(cmd
, list
, dst_name
, flag
);
1711 strbuf_release(&buf
);
1714 static void check_aliased_updates(struct command
*commands
)
1716 struct command
*cmd
;
1717 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
1719 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1720 struct string_list_item
*item
=
1721 string_list_append(&ref_list
, cmd
->ref_name
);
1722 item
->util
= (void *)cmd
;
1724 string_list_sort(&ref_list
);
1726 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1727 if (!cmd
->error_string
)
1728 check_aliased_update(cmd
, &ref_list
);
1731 string_list_clear(&ref_list
, 0);
1734 static const struct object_id
*command_singleton_iterator(void *cb_data
)
1736 struct command
**cmd_list
= cb_data
;
1737 struct command
*cmd
= *cmd_list
;
1739 if (!cmd
|| is_null_oid(&cmd
->new_oid
))
1741 *cmd_list
= NULL
; /* this returns only one */
1742 return &cmd
->new_oid
;
1745 static void set_connectivity_errors(struct command
*commands
,
1746 struct shallow_info
*si
)
1748 struct command
*cmd
;
1750 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1751 struct command
*singleton
= cmd
;
1752 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1754 if (shallow_update
&& si
->shallow_ref
[cmd
->index
])
1755 /* to be checked in update_shallow_ref() */
1758 opt
.env
= tmp_objdir_env(tmp_objdir
);
1759 if (!check_connected(command_singleton_iterator
, &singleton
,
1763 cmd
->error_string
= "missing necessary objects";
1767 struct iterate_data
{
1768 struct command
*cmds
;
1769 struct shallow_info
*si
;
1772 static const struct object_id
*iterate_receive_command_list(void *cb_data
)
1774 struct iterate_data
*data
= cb_data
;
1775 struct command
**cmd_list
= &data
->cmds
;
1776 struct command
*cmd
= *cmd_list
;
1778 for (; cmd
; cmd
= cmd
->next
) {
1779 if (shallow_update
&& data
->si
->shallow_ref
[cmd
->index
])
1780 /* to be checked in update_shallow_ref() */
1782 if (!is_null_oid(&cmd
->new_oid
) && !cmd
->skip_update
) {
1783 *cmd_list
= cmd
->next
;
1784 return &cmd
->new_oid
;
1790 static void reject_updates_to_hidden(struct command
*commands
)
1792 struct strbuf refname_full
= STRBUF_INIT
;
1794 struct command
*cmd
;
1796 strbuf_addstr(&refname_full
, get_git_namespace());
1797 prefix_len
= refname_full
.len
;
1799 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1800 if (cmd
->error_string
)
1803 strbuf_setlen(&refname_full
, prefix_len
);
1804 strbuf_addstr(&refname_full
, cmd
->ref_name
);
1806 if (!ref_is_hidden(cmd
->ref_name
, refname_full
.buf
))
1808 if (is_null_oid(&cmd
->new_oid
))
1809 cmd
->error_string
= "deny deleting a hidden ref";
1811 cmd
->error_string
= "deny updating a hidden ref";
1814 strbuf_release(&refname_full
);
1817 static int should_process_cmd(struct command
*cmd
)
1819 return !cmd
->error_string
&& !cmd
->skip_update
;
1822 static void warn_if_skipped_connectivity_check(struct command
*commands
,
1823 struct shallow_info
*si
)
1825 struct command
*cmd
;
1826 int checked_connectivity
= 1;
1828 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1829 if (should_process_cmd(cmd
) && si
->shallow_ref
[cmd
->index
]) {
1830 error("BUG: connectivity check has not been run on ref %s",
1832 checked_connectivity
= 0;
1835 if (!checked_connectivity
)
1836 BUG("connectivity check skipped???");
1839 static void execute_commands_non_atomic(struct command
*commands
,
1840 struct shallow_info
*si
)
1842 struct command
*cmd
;
1843 struct strbuf err
= STRBUF_INIT
;
1845 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1846 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1849 transaction
= ref_transaction_begin(&err
);
1851 rp_error("%s", err
.buf
);
1853 cmd
->error_string
= "transaction failed to start";
1857 cmd
->error_string
= update(cmd
, si
);
1859 if (!cmd
->error_string
1860 && ref_transaction_commit(transaction
, &err
)) {
1861 rp_error("%s", err
.buf
);
1863 cmd
->error_string
= "failed to update ref";
1865 ref_transaction_free(transaction
);
1867 strbuf_release(&err
);
1870 static void execute_commands_atomic(struct command
*commands
,
1871 struct shallow_info
*si
)
1873 struct command
*cmd
;
1874 struct strbuf err
= STRBUF_INIT
;
1875 const char *reported_error
= "atomic push failure";
1877 transaction
= ref_transaction_begin(&err
);
1879 rp_error("%s", err
.buf
);
1881 reported_error
= "transaction failed to start";
1885 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1886 if (!should_process_cmd(cmd
) || cmd
->run_proc_receive
)
1889 cmd
->error_string
= update(cmd
, si
);
1891 if (cmd
->error_string
)
1895 if (ref_transaction_commit(transaction
, &err
)) {
1896 rp_error("%s", err
.buf
);
1897 reported_error
= "atomic transaction failed";
1903 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1904 if (!cmd
->error_string
)
1905 cmd
->error_string
= reported_error
;
1908 ref_transaction_free(transaction
);
1909 strbuf_release(&err
);
1912 static void execute_commands(struct command
*commands
,
1913 const char *unpacker_error
,
1914 struct shallow_info
*si
,
1915 const struct string_list
*push_options
)
1917 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1918 struct command
*cmd
;
1919 struct iterate_data data
;
1922 int run_proc_receive
= 0;
1924 if (unpacker_error
) {
1925 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1926 cmd
->error_string
= "unpacker error";
1931 memset(&muxer
, 0, sizeof(muxer
));
1932 muxer
.proc
= copy_to_sideband
;
1934 if (!start_async(&muxer
))
1936 /* ...else, continue without relaying sideband */
1939 data
.cmds
= commands
;
1941 opt
.err_fd
= err_fd
;
1942 opt
.progress
= err_fd
&& !quiet
;
1943 opt
.env
= tmp_objdir_env(tmp_objdir
);
1944 if (check_connected(iterate_receive_command_list
, &data
, &opt
))
1945 set_connectivity_errors(commands
, si
);
1948 finish_async(&muxer
);
1950 reject_updates_to_hidden(commands
);
1953 * Try to find commands that have special prefix in their reference names,
1954 * and mark them to run an external "proc-receive" hook later.
1956 if (proc_receive_ref
) {
1957 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1958 if (!should_process_cmd(cmd
))
1961 if (proc_receive_ref_matches(cmd
)) {
1962 cmd
->run_proc_receive
= RUN_PROC_RECEIVE_SCHEDULED
;
1963 run_proc_receive
= 1;
1968 if (run_receive_hook(commands
, "pre-receive", 0, push_options
)) {
1969 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1970 if (!cmd
->error_string
)
1971 cmd
->error_string
= "pre-receive hook declined";
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";
2217 child
.env
= tmp_objdir_env(tmp_objdir
);
2220 * Normally we just pass the tmp_objdir environment to the child
2221 * processes that do the heavy lifting, but we may need to see these
2222 * objects ourselves to set up shallow information.
2224 tmp_objdir_add_as_alternate(tmp_objdir
);
2226 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
2227 strvec_push(&child
.args
, "unpack-objects");
2228 push_header_arg(&child
.args
, &hdr
);
2230 strvec_push(&child
.args
, "-q");
2232 strvec_pushf(&child
.args
, "--strict%s",
2233 fsck_msg_types
.buf
);
2235 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2236 (uintmax_t)max_input_size
);
2237 child
.no_stdout
= 1;
2240 status
= run_command(&child
);
2242 return "unpack-objects abnormal exit";
2244 char hostname
[HOST_NAME_MAX
+ 1];
2246 strvec_pushl(&child
.args
, "index-pack", "--stdin", NULL
);
2247 push_header_arg(&child
.args
, &hdr
);
2249 if (xgethostname(hostname
, sizeof(hostname
)))
2250 xsnprintf(hostname
, sizeof(hostname
), "localhost");
2251 strvec_pushf(&child
.args
,
2252 "--keep=receive-pack %"PRIuMAX
" on %s",
2253 (uintmax_t)getpid(),
2256 if (!quiet
&& err_fd
)
2257 strvec_push(&child
.args
, "--show-resolving-progress");
2259 strvec_push(&child
.args
, "--report-end-of-input");
2261 strvec_pushf(&child
.args
, "--strict%s",
2262 fsck_msg_types
.buf
);
2264 strvec_push(&child
.args
, "--fix-thin");
2266 strvec_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
2267 (uintmax_t)max_input_size
);
2271 status
= start_command(&child
);
2273 return "index-pack fork failed";
2274 pack_lockfile
= index_pack_lockfile(child
.out
, NULL
);
2276 status
= finish_command(&child
);
2278 return "index-pack abnormal exit";
2279 reprepare_packed_git(the_repository
);
2284 static const char *unpack_with_sideband(struct shallow_info
*si
)
2290 return unpack(0, si
);
2292 use_keepalive
= KEEPALIVE_AFTER_NUL
;
2293 memset(&muxer
, 0, sizeof(muxer
));
2294 muxer
.proc
= copy_to_sideband
;
2296 if (start_async(&muxer
))
2299 ret
= unpack(muxer
.in
, si
);
2301 finish_async(&muxer
);
2305 static void prepare_shallow_update(struct shallow_info
*si
)
2307 int i
, j
, k
, bitmap_size
= DIV_ROUND_UP(si
->ref
->nr
, 32);
2309 ALLOC_ARRAY(si
->used_shallow
, si
->shallow
->nr
);
2310 assign_shallow_commits_to_refs(si
, si
->used_shallow
, NULL
);
2312 CALLOC_ARRAY(si
->need_reachability_test
, si
->shallow
->nr
);
2313 CALLOC_ARRAY(si
->reachable
, si
->shallow
->nr
);
2314 CALLOC_ARRAY(si
->shallow_ref
, si
->ref
->nr
);
2316 for (i
= 0; i
< si
->nr_ours
; i
++)
2317 si
->need_reachability_test
[si
->ours
[i
]] = 1;
2319 for (i
= 0; i
< si
->shallow
->nr
; i
++) {
2320 if (!si
->used_shallow
[i
])
2322 for (j
= 0; j
< bitmap_size
; j
++) {
2323 if (!si
->used_shallow
[i
][j
])
2325 si
->need_reachability_test
[i
]++;
2326 for (k
= 0; k
< 32; k
++)
2327 if (si
->used_shallow
[i
][j
] & (1U << k
))
2328 si
->shallow_ref
[j
* 32 + k
]++;
2332 * true for those associated with some refs and belong
2333 * in "ours" list aka "step 7 not done yet"
2335 si
->need_reachability_test
[i
] =
2336 si
->need_reachability_test
[i
] > 1;
2340 * keep hooks happy by forcing a temporary shallow file via
2341 * env variable because we can't add --shallow-file to every
2342 * command. check_connected() will be done with
2343 * true .git/shallow though.
2345 setenv(GIT_SHALLOW_FILE_ENVIRONMENT
, alt_shallow_file
, 1);
2348 static void update_shallow_info(struct command
*commands
,
2349 struct shallow_info
*si
,
2350 struct oid_array
*ref
)
2352 struct command
*cmd
;
2354 remove_nonexistent_theirs_shallow(si
);
2355 if (!si
->nr_ours
&& !si
->nr_theirs
) {
2360 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2361 if (is_null_oid(&cmd
->new_oid
))
2363 oid_array_append(ref
, &cmd
->new_oid
);
2364 cmd
->index
= ref
->nr
- 1;
2368 if (shallow_update
) {
2369 prepare_shallow_update(si
);
2373 ALLOC_ARRAY(ref_status
, ref
->nr
);
2374 assign_shallow_commits_to_refs(si
, NULL
, ref_status
);
2375 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2376 if (is_null_oid(&cmd
->new_oid
))
2378 if (ref_status
[cmd
->index
]) {
2379 cmd
->error_string
= "shallow update not allowed";
2380 cmd
->skip_update
= 1;
2386 static void report(struct command
*commands
, const char *unpack_status
)
2388 struct command
*cmd
;
2389 struct strbuf buf
= STRBUF_INIT
;
2391 packet_buf_write(&buf
, "unpack %s\n",
2392 unpack_status
? unpack_status
: "ok");
2393 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2394 if (!cmd
->error_string
)
2395 packet_buf_write(&buf
, "ok %s\n",
2398 packet_buf_write(&buf
, "ng %s %s\n",
2399 cmd
->ref_name
, cmd
->error_string
);
2401 packet_buf_flush(&buf
);
2404 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2406 write_or_die(1, buf
.buf
, buf
.len
);
2407 strbuf_release(&buf
);
2410 static void report_v2(struct command
*commands
, const char *unpack_status
)
2412 struct command
*cmd
;
2413 struct strbuf buf
= STRBUF_INIT
;
2414 struct ref_push_report
*report
;
2416 packet_buf_write(&buf
, "unpack %s\n",
2417 unpack_status
? unpack_status
: "ok");
2418 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2421 if (cmd
->error_string
) {
2422 packet_buf_write(&buf
, "ng %s %s\n",
2427 packet_buf_write(&buf
, "ok %s\n",
2429 for (report
= cmd
->report
; report
; report
= report
->next
) {
2431 packet_buf_write(&buf
, "ok %s\n",
2433 if (report
->ref_name
)
2434 packet_buf_write(&buf
, "option refname %s\n",
2436 if (report
->old_oid
)
2437 packet_buf_write(&buf
, "option old-oid %s\n",
2438 oid_to_hex(report
->old_oid
));
2439 if (report
->new_oid
)
2440 packet_buf_write(&buf
, "option new-oid %s\n",
2441 oid_to_hex(report
->new_oid
));
2442 if (report
->forced_update
)
2443 packet_buf_write(&buf
, "option forced-update\n");
2446 packet_buf_flush(&buf
);
2449 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
2451 write_or_die(1, buf
.buf
, buf
.len
);
2452 strbuf_release(&buf
);
2455 static int delete_only(struct command
*commands
)
2457 struct command
*cmd
;
2458 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
2459 if (!is_null_oid(&cmd
->new_oid
))
2465 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
2467 int advertise_refs
= 0;
2468 struct command
*commands
;
2469 struct oid_array shallow
= OID_ARRAY_INIT
;
2470 struct oid_array ref
= OID_ARRAY_INIT
;
2471 struct shallow_info si
;
2472 struct packet_reader reader
;
2474 struct option options
[] = {
2475 OPT__QUIET(&quiet
, N_("quiet")),
2476 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc
, NULL
),
2477 OPT_HIDDEN_BOOL(0, "http-backend-info-refs", &advertise_refs
, NULL
),
2478 OPT_ALIAS(0, "advertise-refs", "http-backend-info-refs"),
2479 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin
, NULL
),
2483 packet_trace_identity("receive-pack");
2485 argc
= parse_options(argc
, argv
, prefix
, options
, receive_pack_usage
, 0);
2488 usage_msg_opt(_("Too many arguments."), receive_pack_usage
, options
);
2490 usage_msg_opt(_("You must specify a directory."), receive_pack_usage
, options
);
2492 service_dir
= argv
[0];
2496 if (!enter_repo(service_dir
, 0))
2497 die("'%s' does not appear to be a git repository", service_dir
);
2499 git_config(receive_pack_config
, NULL
);
2500 if (cert_nonce_seed
)
2501 push_cert_nonce
= prepare_push_cert_nonce(service_dir
, time(NULL
));
2503 if (0 <= transfer_unpack_limit
)
2504 unpack_limit
= transfer_unpack_limit
;
2505 else if (0 <= receive_unpack_limit
)
2506 unpack_limit
= receive_unpack_limit
;
2508 switch (determine_protocol_version_server()) {
2511 * push support for protocol v2 has not been implemented yet,
2512 * so ignore the request to use v2 and fallback to using v0.
2517 * v1 is just the original protocol with a version string,
2518 * so just fall through after writing the version string.
2520 if (advertise_refs
|| !stateless_rpc
)
2521 packet_write_fmt(1, "version 1\n");
2526 case protocol_unknown_version
:
2527 BUG("unknown protocol version");
2530 if (advertise_refs
|| !stateless_rpc
) {
2536 packet_reader_init(&reader
, 0, NULL
, 0,
2537 PACKET_READ_CHOMP_NEWLINE
|
2538 PACKET_READ_DIE_ON_ERR_PACKET
);
2540 if ((commands
= read_head_info(&reader
, &shallow
)) != NULL
) {
2541 const char *unpack_status
= NULL
;
2542 struct string_list push_options
= STRING_LIST_INIT_DUP
;
2544 if (use_push_options
)
2545 read_push_options(&reader
, &push_options
);
2546 if (!check_cert_push_options(&push_options
)) {
2547 struct command
*cmd
;
2548 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
2549 cmd
->error_string
= "inconsistent push options";
2552 prepare_shallow_info(&si
, &shallow
);
2553 if (!si
.nr_ours
&& !si
.nr_theirs
)
2555 if (!delete_only(commands
)) {
2556 unpack_status
= unpack_with_sideband(&si
);
2557 update_shallow_info(commands
, &si
, &ref
);
2559 use_keepalive
= KEEPALIVE_ALWAYS
;
2560 execute_commands(commands
, unpack_status
, &si
,
2563 unlink_or_warn(pack_lockfile
);
2564 if (report_status_v2
)
2565 report_v2(commands
, unpack_status
);
2566 else if (report_status
)
2567 report(commands
, unpack_status
);
2568 run_receive_hook(commands
, "post-receive", 1,
2570 run_update_post_hook(commands
);
2571 string_list_clear(&push_options
, 0);
2573 const char *argv_gc_auto
[] = {
2574 "gc", "--auto", "--quiet", NULL
,
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 proc
.argv
= argv_gc_auto
;
2584 if (!start_command(&proc
)) {
2586 copy_to_sideband(proc
.err
, -1, NULL
);
2587 finish_command(&proc
);
2590 if (auto_update_server_info
)
2591 update_server_info(0);
2592 clear_shallow_info(&si
);
2596 oid_array_clear(&shallow
);
2597 oid_array_clear(&ref
);
2598 free((void *)push_cert_nonce
);