2 #include "repository.h"
9 #include "run-command.h"
15 #include "transport.h"
16 #include "string-list.h"
17 #include "sha1-array.h"
18 #include "connected.h"
19 #include "argv-array.h"
22 #include "gpg-interface.h"
25 #include "tmp-objdir.h"
30 static const char * const receive_pack_usage
[] = {
31 N_("git receive-pack <git-dir>"),
43 static int deny_deletes
;
44 static int deny_non_fast_forwards
;
45 static enum deny_action deny_current_branch
= DENY_UNCONFIGURED
;
46 static enum deny_action deny_delete_current
= DENY_UNCONFIGURED
;
47 static int receive_fsck_objects
= -1;
48 static int transfer_fsck_objects
= -1;
49 static struct strbuf fsck_msg_types
= STRBUF_INIT
;
50 static int receive_unpack_limit
= -1;
51 static int transfer_unpack_limit
= -1;
52 static int advertise_atomic_push
= 1;
53 static int advertise_push_options
;
54 static int unpack_limit
= 100;
55 static off_t max_input_size
;
56 static int report_status
;
57 static int use_sideband
;
58 static int use_atomic
;
59 static int use_push_options
;
61 static int prefer_ofs_delta
= 1;
62 static int auto_update_server_info
;
63 static int auto_gc
= 1;
64 static int reject_thin
;
65 static int stateless_rpc
;
66 static const char *service_dir
;
67 static const char *head_name
;
68 static void *head_name_to_free
;
69 static int sent_capabilities
;
70 static int shallow_update
;
71 static const char *alt_shallow_file
;
72 static struct strbuf push_cert
= STRBUF_INIT
;
73 static unsigned char push_cert_sha1
[20];
74 static struct signature_check sigcheck
;
75 static const char *push_cert_nonce
;
76 static const char *cert_nonce_seed
;
78 static const char *NONCE_UNSOLICITED
= "UNSOLICITED";
79 static const char *NONCE_BAD
= "BAD";
80 static const char *NONCE_MISSING
= "MISSING";
81 static const char *NONCE_OK
= "OK";
82 static const char *NONCE_SLOP
= "SLOP";
83 static const char *nonce_status
;
84 static long nonce_stamp_slop
;
85 static timestamp_t nonce_stamp_slop_limit
;
86 static struct ref_transaction
*transaction
;
93 static int keepalive_in_sec
= 5;
95 static struct tmp_objdir
*tmp_objdir
;
97 static enum deny_action
parse_deny_action(const char *var
, const char *value
)
100 if (!strcasecmp(value
, "ignore"))
102 if (!strcasecmp(value
, "warn"))
104 if (!strcasecmp(value
, "refuse"))
106 if (!strcasecmp(value
, "updateinstead"))
107 return DENY_UPDATE_INSTEAD
;
109 if (git_config_bool(var
, value
))
114 static int receive_pack_config(const char *var
, const char *value
, void *cb
)
116 int status
= parse_hide_refs_config(var
, value
, "receive");
121 if (strcmp(var
, "receive.denydeletes") == 0) {
122 deny_deletes
= git_config_bool(var
, value
);
126 if (strcmp(var
, "receive.denynonfastforwards") == 0) {
127 deny_non_fast_forwards
= git_config_bool(var
, value
);
131 if (strcmp(var
, "receive.unpacklimit") == 0) {
132 receive_unpack_limit
= git_config_int(var
, value
);
136 if (strcmp(var
, "transfer.unpacklimit") == 0) {
137 transfer_unpack_limit
= git_config_int(var
, value
);
141 if (strcmp(var
, "receive.fsck.skiplist") == 0) {
144 if (git_config_pathname(&path
, var
, value
))
146 strbuf_addf(&fsck_msg_types
, "%cskiplist=%s",
147 fsck_msg_types
.len
? ',' : '=', path
);
152 if (skip_prefix(var
, "receive.fsck.", &var
)) {
153 if (is_valid_msg_type(var
, value
))
154 strbuf_addf(&fsck_msg_types
, "%c%s=%s",
155 fsck_msg_types
.len
? ',' : '=', var
, value
);
157 warning("Skipping unknown msg id '%s'", var
);
161 if (strcmp(var
, "receive.fsckobjects") == 0) {
162 receive_fsck_objects
= git_config_bool(var
, value
);
166 if (strcmp(var
, "transfer.fsckobjects") == 0) {
167 transfer_fsck_objects
= git_config_bool(var
, value
);
171 if (!strcmp(var
, "receive.denycurrentbranch")) {
172 deny_current_branch
= parse_deny_action(var
, value
);
176 if (strcmp(var
, "receive.denydeletecurrent") == 0) {
177 deny_delete_current
= parse_deny_action(var
, value
);
181 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
182 prefer_ofs_delta
= git_config_bool(var
, value
);
186 if (strcmp(var
, "receive.updateserverinfo") == 0) {
187 auto_update_server_info
= git_config_bool(var
, value
);
191 if (strcmp(var
, "receive.autogc") == 0) {
192 auto_gc
= git_config_bool(var
, value
);
196 if (strcmp(var
, "receive.shallowupdate") == 0) {
197 shallow_update
= git_config_bool(var
, value
);
201 if (strcmp(var
, "receive.certnonceseed") == 0)
202 return git_config_string(&cert_nonce_seed
, var
, value
);
204 if (strcmp(var
, "receive.certnonceslop") == 0) {
205 nonce_stamp_slop_limit
= git_config_ulong(var
, value
);
209 if (strcmp(var
, "receive.advertiseatomic") == 0) {
210 advertise_atomic_push
= git_config_bool(var
, value
);
214 if (strcmp(var
, "receive.advertisepushoptions") == 0) {
215 advertise_push_options
= git_config_bool(var
, value
);
219 if (strcmp(var
, "receive.keepalive") == 0) {
220 keepalive_in_sec
= git_config_int(var
, value
);
224 if (strcmp(var
, "receive.maxinputsize") == 0) {
225 max_input_size
= git_config_int64(var
, value
);
229 return git_default_config(var
, value
, cb
);
232 static void show_ref(const char *path
, const struct object_id
*oid
)
234 if (sent_capabilities
) {
235 packet_write_fmt(1, "%s %s\n", oid_to_hex(oid
), path
);
237 struct strbuf cap
= STRBUF_INIT
;
240 "report-status delete-refs side-band-64k quiet");
241 if (advertise_atomic_push
)
242 strbuf_addstr(&cap
, " atomic");
243 if (prefer_ofs_delta
)
244 strbuf_addstr(&cap
, " ofs-delta");
246 strbuf_addf(&cap
, " push-cert=%s", push_cert_nonce
);
247 if (advertise_push_options
)
248 strbuf_addstr(&cap
, " push-options");
249 strbuf_addf(&cap
, " agent=%s", git_user_agent_sanitized());
250 packet_write_fmt(1, "%s %s%c%s\n",
251 oid_to_hex(oid
), path
, 0, cap
.buf
);
252 strbuf_release(&cap
);
253 sent_capabilities
= 1;
257 static int show_ref_cb(const char *path_full
, const struct object_id
*oid
,
258 int flag
, void *data
)
260 struct oidset
*seen
= data
;
261 const char *path
= strip_namespace(path_full
);
263 if (ref_is_hidden(path
, path_full
))
267 * Advertise refs outside our current namespace as ".have"
268 * refs, so that the client can use them to minimize data
269 * transfer but will otherwise ignore them.
272 if (oidset_insert(seen
, oid
))
276 oidset_insert(seen
, oid
);
282 static void show_one_alternate_ref(const char *refname
,
283 const struct object_id
*oid
,
286 struct oidset
*seen
= data
;
288 if (oidset_insert(seen
, oid
))
291 show_ref(".have", oid
);
294 static void write_head_info(void)
296 static struct oidset seen
= OIDSET_INIT
;
298 for_each_ref(show_ref_cb
, &seen
);
299 for_each_alternate_ref(show_one_alternate_ref
, &seen
);
301 if (!sent_capabilities
)
302 show_ref("capabilities^{}", &null_oid
);
304 advertise_shallow_grafts(1);
311 struct command
*next
;
312 const char *error_string
;
313 unsigned int skip_update
:1,
316 struct object_id old_oid
;
317 struct object_id new_oid
;
318 char ref_name
[FLEX_ARRAY
]; /* more */
321 static void rp_error(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
322 static void rp_warning(const char *err
, ...) __attribute__((format (printf
, 1, 2)));
324 static void report_message(const char *prefix
, const char *err
, va_list params
)
329 sz
= xsnprintf(msg
, sizeof(msg
), "%s", prefix
);
330 sz
+= vsnprintf(msg
+ sz
, sizeof(msg
) - sz
, err
, params
);
331 if (sz
> (sizeof(msg
) - 1))
332 sz
= sizeof(msg
) - 1;
336 send_sideband(1, 2, msg
, sz
, use_sideband
);
341 static void rp_warning(const char *err
, ...)
344 va_start(params
, err
);
345 report_message("warning: ", err
, params
);
349 static void rp_error(const char *err
, ...)
352 va_start(params
, err
);
353 report_message("error: ", err
, params
);
357 static int copy_to_sideband(int in
, int out
, void *arg
)
360 int keepalive_active
= 0;
362 if (keepalive_in_sec
<= 0)
363 use_keepalive
= KEEPALIVE_NEVER
;
364 if (use_keepalive
== KEEPALIVE_ALWAYS
)
365 keepalive_active
= 1;
370 if (keepalive_active
) {
376 ret
= poll(&pfd
, 1, 1000 * keepalive_in_sec
);
383 } else if (ret
== 0) {
384 /* no data; send a keepalive packet */
385 static const char buf
[] = "0005\1";
386 write_or_die(1, buf
, sizeof(buf
) - 1);
388 } /* else there is actual data to read */
391 sz
= xread(in
, data
, sizeof(data
));
395 if (use_keepalive
== KEEPALIVE_AFTER_NUL
&& !keepalive_active
) {
396 const char *p
= memchr(data
, '\0', sz
);
399 * The NUL tells us to start sending keepalives. Make
400 * sure we send any other data we read along
403 keepalive_active
= 1;
404 send_sideband(1, 2, data
, p
- data
, use_sideband
);
405 send_sideband(1, 2, p
+ 1, sz
- (p
- data
+ 1), use_sideband
);
411 * Either we're not looking for a NUL signal, or we didn't see
412 * it yet; just pass along the data.
414 send_sideband(1, 2, data
, sz
, use_sideband
);
420 #define HMAC_BLOCK_SIZE 64
422 static void hmac_sha1(unsigned char *out
,
423 const char *key_in
, size_t key_len
,
424 const char *text
, size_t text_len
)
426 unsigned char key
[HMAC_BLOCK_SIZE
];
427 unsigned char k_ipad
[HMAC_BLOCK_SIZE
];
428 unsigned char k_opad
[HMAC_BLOCK_SIZE
];
432 /* RFC 2104 2. (1) */
433 memset(key
, '\0', HMAC_BLOCK_SIZE
);
434 if (HMAC_BLOCK_SIZE
< key_len
) {
436 git_SHA1_Update(&ctx
, key_in
, key_len
);
437 git_SHA1_Final(key
, &ctx
);
439 memcpy(key
, key_in
, key_len
);
442 /* RFC 2104 2. (2) & (5) */
443 for (i
= 0; i
< sizeof(key
); i
++) {
444 k_ipad
[i
] = key
[i
] ^ 0x36;
445 k_opad
[i
] = key
[i
] ^ 0x5c;
448 /* RFC 2104 2. (3) & (4) */
450 git_SHA1_Update(&ctx
, k_ipad
, sizeof(k_ipad
));
451 git_SHA1_Update(&ctx
, text
, text_len
);
452 git_SHA1_Final(out
, &ctx
);
454 /* RFC 2104 2. (6) & (7) */
456 git_SHA1_Update(&ctx
, k_opad
, sizeof(k_opad
));
457 git_SHA1_Update(&ctx
, out
, 20);
458 git_SHA1_Final(out
, &ctx
);
461 static char *prepare_push_cert_nonce(const char *path
, timestamp_t stamp
)
463 struct strbuf buf
= STRBUF_INIT
;
464 unsigned char sha1
[20];
466 strbuf_addf(&buf
, "%s:%"PRItime
, path
, stamp
);
467 hmac_sha1(sha1
, buf
.buf
, buf
.len
, cert_nonce_seed
, strlen(cert_nonce_seed
));;
468 strbuf_release(&buf
);
470 /* RFC 2104 5. HMAC-SHA1-80 */
471 strbuf_addf(&buf
, "%"PRItime
"-%.*s", stamp
, 20, sha1_to_hex(sha1
));
472 return strbuf_detach(&buf
, NULL
);
476 * NEEDSWORK: reuse find_commit_header() from jk/commit-author-parsing
477 * after dropping "_commit" from its name and possibly moving it out
480 static char *find_header(const char *msg
, size_t len
, const char *key
,
481 const char **next_line
)
483 int key_len
= strlen(key
);
484 const char *line
= msg
;
486 while (line
&& line
< msg
+ len
) {
487 const char *eol
= strchrnul(line
, '\n');
489 if ((msg
+ len
<= eol
) || line
== eol
)
491 if (line
+ key_len
< eol
&&
492 !memcmp(line
, key
, key_len
) && line
[key_len
] == ' ') {
493 int offset
= key_len
+ 1;
495 *next_line
= *eol
? eol
+ 1 : eol
;
496 return xmemdupz(line
+ offset
, (eol
- line
) - offset
);
498 line
= *eol
? eol
+ 1 : NULL
;
503 static const char *check_nonce(const char *buf
, size_t len
)
505 char *nonce
= find_header(buf
, len
, "nonce", NULL
);
506 timestamp_t stamp
, ostamp
;
507 char *bohmac
, *expect
= NULL
;
508 const char *retval
= NONCE_BAD
;
511 retval
= NONCE_MISSING
;
513 } else if (!push_cert_nonce
) {
514 retval
= NONCE_UNSOLICITED
;
516 } else if (!strcmp(push_cert_nonce
, nonce
)) {
521 if (!stateless_rpc
) {
522 /* returned nonce MUST match what we gave out earlier */
528 * In stateless mode, we may be receiving a nonce issued by
529 * another instance of the server that serving the same
530 * repository, and the timestamps may not match, but the
531 * nonce-seed and dir should match, so we can recompute and
532 * report the time slop.
534 * In addition, when a nonce issued by another instance has
535 * timestamp within receive.certnonceslop seconds, we pretend
536 * as if we issued that nonce when reporting to the hook.
539 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
540 if (*nonce
<= '0' || '9' < *nonce
) {
544 stamp
= parse_timestamp(nonce
, &bohmac
, 10);
545 if (bohmac
== nonce
|| bohmac
[0] != '-') {
550 expect
= prepare_push_cert_nonce(service_dir
, stamp
);
551 if (strcmp(expect
, nonce
)) {
552 /* Not what we would have signed earlier */
558 * By how many seconds is this nonce stale? Negative value
559 * would mean it was issued by another server with its clock
560 * skewed in the future.
562 ostamp
= parse_timestamp(push_cert_nonce
, NULL
, 10);
563 nonce_stamp_slop
= (long)ostamp
- (long)stamp
;
565 if (nonce_stamp_slop_limit
&&
566 labs(nonce_stamp_slop
) <= nonce_stamp_slop_limit
) {
568 * Pretend as if the received nonce (which passes the
569 * HMAC check, so it is not a forged by third-party)
572 free((void *)push_cert_nonce
);
573 push_cert_nonce
= xstrdup(nonce
);
586 * Return 1 if there is no push_cert or if the push options in push_cert are
587 * the same as those in the argument; 0 otherwise.
589 static int check_cert_push_options(const struct string_list
*push_options
)
591 const char *buf
= push_cert
.buf
;
592 int len
= push_cert
.len
;
595 const char *next_line
;
596 int options_seen
= 0;
603 while ((option
= find_header(buf
, len
, "push-option", &next_line
))) {
604 len
-= (next_line
- buf
);
607 if (options_seen
> push_options
->nr
609 push_options
->items
[options_seen
- 1].string
)) {
616 if (options_seen
!= push_options
->nr
)
624 static void prepare_push_cert_sha1(struct child_process
*proc
)
626 static int already_done
;
632 struct strbuf gpg_output
= STRBUF_INIT
;
633 struct strbuf gpg_status
= STRBUF_INIT
;
634 int bogs
/* beginning_of_gpg_sig */;
637 if (write_sha1_file(push_cert
.buf
, push_cert
.len
, "blob", push_cert_sha1
))
638 hashclr(push_cert_sha1
);
640 memset(&sigcheck
, '\0', sizeof(sigcheck
));
641 sigcheck
.result
= 'N';
643 bogs
= parse_signature(push_cert
.buf
, push_cert
.len
);
644 if (verify_signed_buffer(push_cert
.buf
, bogs
,
645 push_cert
.buf
+ bogs
, push_cert
.len
- bogs
,
646 &gpg_output
, &gpg_status
) < 0) {
647 ; /* error running gpg */
649 sigcheck
.payload
= push_cert
.buf
;
650 sigcheck
.gpg_output
= gpg_output
.buf
;
651 sigcheck
.gpg_status
= gpg_status
.buf
;
652 parse_gpg_output(&sigcheck
);
655 strbuf_release(&gpg_output
);
656 strbuf_release(&gpg_status
);
657 nonce_status
= check_nonce(push_cert
.buf
, bogs
);
659 if (!is_null_sha1(push_cert_sha1
)) {
660 argv_array_pushf(&proc
->env_array
, "GIT_PUSH_CERT=%s",
661 sha1_to_hex(push_cert_sha1
));
662 argv_array_pushf(&proc
->env_array
, "GIT_PUSH_CERT_SIGNER=%s",
663 sigcheck
.signer
? sigcheck
.signer
: "");
664 argv_array_pushf(&proc
->env_array
, "GIT_PUSH_CERT_KEY=%s",
665 sigcheck
.key
? sigcheck
.key
: "");
666 argv_array_pushf(&proc
->env_array
, "GIT_PUSH_CERT_STATUS=%c",
668 if (push_cert_nonce
) {
669 argv_array_pushf(&proc
->env_array
,
670 "GIT_PUSH_CERT_NONCE=%s",
672 argv_array_pushf(&proc
->env_array
,
673 "GIT_PUSH_CERT_NONCE_STATUS=%s",
675 if (nonce_status
== NONCE_SLOP
)
676 argv_array_pushf(&proc
->env_array
,
677 "GIT_PUSH_CERT_NONCE_SLOP=%ld",
683 struct receive_hook_feed_state
{
687 const struct string_list
*push_options
;
690 typedef int (*feed_fn
)(void *, const char **, size_t *);
691 static int run_and_feed_hook(const char *hook_name
, feed_fn feed
,
692 struct receive_hook_feed_state
*feed_state
)
694 struct child_process proc
= CHILD_PROCESS_INIT
;
699 argv
[0] = find_hook(hook_name
);
707 proc
.stdout_to_stderr
= 1;
708 if (feed_state
->push_options
) {
710 for (i
= 0; i
< feed_state
->push_options
->nr
; i
++)
711 argv_array_pushf(&proc
.env_array
,
712 "GIT_PUSH_OPTION_%d=%s", i
,
713 feed_state
->push_options
->items
[i
].string
);
714 argv_array_pushf(&proc
.env_array
, "GIT_PUSH_OPTION_COUNT=%d",
715 feed_state
->push_options
->nr
);
717 argv_array_pushf(&proc
.env_array
, "GIT_PUSH_OPTION_COUNT");
720 argv_array_pushv(&proc
.env_array
, tmp_objdir_env(tmp_objdir
));
723 memset(&muxer
, 0, sizeof(muxer
));
724 muxer
.proc
= copy_to_sideband
;
726 code
= start_async(&muxer
);
732 prepare_push_cert_sha1(&proc
);
734 code
= start_command(&proc
);
737 finish_async(&muxer
);
741 sigchain_push(SIGPIPE
, SIG_IGN
);
746 if (feed(feed_state
, &buf
, &n
))
748 if (write_in_full(proc
.in
, buf
, n
) < 0)
753 finish_async(&muxer
);
755 sigchain_pop(SIGPIPE
);
757 return finish_command(&proc
);
760 static int feed_receive_hook(void *state_
, const char **bufp
, size_t *sizep
)
762 struct receive_hook_feed_state
*state
= state_
;
763 struct command
*cmd
= state
->cmd
;
766 state
->skip_broken
&& (cmd
->error_string
|| cmd
->did_not_exist
))
770 strbuf_reset(&state
->buf
);
771 strbuf_addf(&state
->buf
, "%s %s %s\n",
772 oid_to_hex(&cmd
->old_oid
), oid_to_hex(&cmd
->new_oid
),
774 state
->cmd
= cmd
->next
;
776 *bufp
= state
->buf
.buf
;
777 *sizep
= state
->buf
.len
;
782 static int run_receive_hook(struct command
*commands
,
783 const char *hook_name
,
785 const struct string_list
*push_options
)
787 struct receive_hook_feed_state state
;
790 strbuf_init(&state
.buf
, 0);
791 state
.cmd
= commands
;
792 state
.skip_broken
= skip_broken
;
793 if (feed_receive_hook(&state
, NULL
, NULL
))
795 state
.cmd
= commands
;
796 state
.push_options
= push_options
;
797 status
= run_and_feed_hook(hook_name
, feed_receive_hook
, &state
);
798 strbuf_release(&state
.buf
);
802 static int run_update_hook(struct command
*cmd
)
805 struct child_process proc
= CHILD_PROCESS_INIT
;
808 argv
[0] = find_hook("update");
812 argv
[1] = cmd
->ref_name
;
813 argv
[2] = oid_to_hex(&cmd
->old_oid
);
814 argv
[3] = oid_to_hex(&cmd
->new_oid
);
818 proc
.stdout_to_stderr
= 1;
819 proc
.err
= use_sideband
? -1 : 0;
822 code
= start_command(&proc
);
826 copy_to_sideband(proc
.err
, -1, NULL
);
827 return finish_command(&proc
);
830 static int is_ref_checked_out(const char *ref
)
832 if (is_bare_repository())
837 return !strcmp(head_name
, ref
);
840 static char *refuse_unconfigured_deny_msg
=
841 N_("By default, updating the current branch in a non-bare repository\n"
842 "is denied, because it will make the index and work tree inconsistent\n"
843 "with what you pushed, and will require 'git reset --hard' to match\n"
844 "the work tree to HEAD.\n"
846 "You can set the 'receive.denyCurrentBranch' configuration variable\n"
847 "to 'ignore' or 'warn' in the remote repository to allow pushing into\n"
848 "its current branch; however, this is not recommended unless you\n"
849 "arranged to update its work tree to match what you pushed in some\n"
852 "To squelch this message and still keep the default behaviour, set\n"
853 "'receive.denyCurrentBranch' configuration variable to 'refuse'.");
855 static void refuse_unconfigured_deny(void)
857 rp_error("%s", _(refuse_unconfigured_deny_msg
));
860 static char *refuse_unconfigured_deny_delete_current_msg
=
861 N_("By default, deleting the current branch is denied, because the next\n"
862 "'git clone' won't result in any file checked out, causing confusion.\n"
864 "You can set 'receive.denyDeleteCurrent' configuration variable to\n"
865 "'warn' or 'ignore' in the remote repository to allow deleting the\n"
866 "current branch, with or without a warning message.\n"
868 "To squelch this message, you can set it to 'refuse'.");
870 static void refuse_unconfigured_deny_delete_current(void)
872 rp_error("%s", _(refuse_unconfigured_deny_delete_current_msg
));
875 static int command_singleton_iterator(void *cb_data
, struct object_id
*oid
);
876 static int update_shallow_ref(struct command
*cmd
, struct shallow_info
*si
)
878 static struct lock_file shallow_lock
;
879 struct oid_array extra
= OID_ARRAY_INIT
;
880 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
881 uint32_t mask
= 1 << (cmd
->index
% 32);
884 trace_printf_key(&trace_shallow
,
885 "shallow: update_shallow_ref %s\n", cmd
->ref_name
);
886 for (i
= 0; i
< si
->shallow
->nr
; i
++)
887 if (si
->used_shallow
[i
] &&
888 (si
->used_shallow
[i
][cmd
->index
/ 32] & mask
) &&
889 !delayed_reachability_test(si
, i
))
890 oid_array_append(&extra
, &si
->shallow
->oid
[i
]);
892 opt
.env
= tmp_objdir_env(tmp_objdir
);
893 setup_alternate_shallow(&shallow_lock
, &opt
.shallow_file
, &extra
);
894 if (check_connected(command_singleton_iterator
, cmd
, &opt
)) {
895 rollback_lock_file(&shallow_lock
);
896 oid_array_clear(&extra
);
900 commit_lock_file(&shallow_lock
);
903 * Make sure setup_alternate_shallow() for the next ref does
904 * not lose these new roots..
906 for (i
= 0; i
< extra
.nr
; i
++)
907 register_shallow(&extra
.oid
[i
]);
909 si
->shallow_ref
[cmd
->index
] = 0;
910 oid_array_clear(&extra
);
915 * NEEDSWORK: we should consolidate various implementions of "are we
916 * on an unborn branch?" test into one, and make the unified one more
917 * robust. !get_sha1() based check used here and elsewhere would not
918 * allow us to tell an unborn branch from corrupt ref, for example.
919 * For the purpose of fixing "deploy-to-update does not work when
920 * pushing into an empty repository" issue, this should suffice for
923 static int head_has_history(void)
925 struct object_id oid
;
927 return !get_oid("HEAD", &oid
);
930 static const char *push_to_deploy(unsigned char *sha1
,
931 struct argv_array
*env
,
932 const char *work_tree
)
934 const char *update_refresh
[] = {
935 "update-index", "-q", "--ignore-submodules", "--refresh", NULL
937 const char *diff_files
[] = {
938 "diff-files", "--quiet", "--ignore-submodules", "--", NULL
940 const char *diff_index
[] = {
941 "diff-index", "--quiet", "--cached", "--ignore-submodules",
944 const char *read_tree
[] = {
945 "read-tree", "-u", "-m", NULL
, NULL
947 struct child_process child
= CHILD_PROCESS_INIT
;
949 child
.argv
= update_refresh
;
950 child
.env
= env
->argv
;
951 child
.dir
= work_tree
;
953 child
.stdout_to_stderr
= 1;
955 if (run_command(&child
))
956 return "Up-to-date check failed";
958 /* run_command() does not clean up completely; reinitialize */
959 child_process_init(&child
);
960 child
.argv
= diff_files
;
961 child
.env
= env
->argv
;
962 child
.dir
= work_tree
;
964 child
.stdout_to_stderr
= 1;
966 if (run_command(&child
))
967 return "Working directory has unstaged changes";
969 /* diff-index with either HEAD or an empty tree */
970 diff_index
[4] = head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
;
972 child_process_init(&child
);
973 child
.argv
= diff_index
;
974 child
.env
= env
->argv
;
977 child
.stdout_to_stderr
= 0;
979 if (run_command(&child
))
980 return "Working directory has staged changes";
982 read_tree
[3] = sha1_to_hex(sha1
);
983 child_process_init(&child
);
984 child
.argv
= read_tree
;
985 child
.env
= env
->argv
;
986 child
.dir
= work_tree
;
989 child
.stdout_to_stderr
= 0;
991 if (run_command(&child
))
992 return "Could not update working tree to new HEAD";
997 static const char *push_to_checkout_hook
= "push-to-checkout";
999 static const char *push_to_checkout(unsigned char *sha1
,
1000 struct argv_array
*env
,
1001 const char *work_tree
)
1003 argv_array_pushf(env
, "GIT_WORK_TREE=%s", absolute_path(work_tree
));
1004 if (run_hook_le(env
->argv
, push_to_checkout_hook
,
1005 sha1_to_hex(sha1
), NULL
))
1006 return "push-to-checkout hook declined";
1011 static const char *update_worktree(unsigned char *sha1
)
1014 const char *work_tree
= git_work_tree_cfg
? git_work_tree_cfg
: "..";
1015 struct argv_array env
= ARGV_ARRAY_INIT
;
1017 if (is_bare_repository())
1018 return "denyCurrentBranch = updateInstead needs a worktree";
1020 argv_array_pushf(&env
, "GIT_DIR=%s", absolute_path(get_git_dir()));
1022 if (!find_hook(push_to_checkout_hook
))
1023 retval
= push_to_deploy(sha1
, &env
, work_tree
);
1025 retval
= push_to_checkout(sha1
, &env
, work_tree
);
1027 argv_array_clear(&env
);
1031 static const char *update(struct command
*cmd
, struct shallow_info
*si
)
1033 const char *name
= cmd
->ref_name
;
1034 struct strbuf namespaced_name_buf
= STRBUF_INIT
;
1035 static char *namespaced_name
;
1037 struct object_id
*old_oid
= &cmd
->old_oid
;
1038 struct object_id
*new_oid
= &cmd
->new_oid
;
1040 /* only refs/... are allowed */
1041 if (!starts_with(name
, "refs/") || check_refname_format(name
+ 5, 0)) {
1042 rp_error("refusing to create funny ref '%s' remotely", name
);
1043 return "funny refname";
1046 strbuf_addf(&namespaced_name_buf
, "%s%s", get_git_namespace(), name
);
1047 free(namespaced_name
);
1048 namespaced_name
= strbuf_detach(&namespaced_name_buf
, NULL
);
1050 if (is_ref_checked_out(namespaced_name
)) {
1051 switch (deny_current_branch
) {
1055 rp_warning("updating the current branch");
1058 case DENY_UNCONFIGURED
:
1059 rp_error("refusing to update checked out branch: %s", name
);
1060 if (deny_current_branch
== DENY_UNCONFIGURED
)
1061 refuse_unconfigured_deny();
1062 return "branch is currently checked out";
1063 case DENY_UPDATE_INSTEAD
:
1064 ret
= update_worktree(new_oid
->hash
);
1071 if (!is_null_oid(new_oid
) && !has_object_file(new_oid
)) {
1072 error("unpack should have generated %s, "
1073 "but I can't find it!", oid_to_hex(new_oid
));
1077 if (!is_null_oid(old_oid
) && is_null_oid(new_oid
)) {
1078 if (deny_deletes
&& starts_with(name
, "refs/heads/")) {
1079 rp_error("denying ref deletion for %s", name
);
1080 return "deletion prohibited";
1083 if (head_name
&& !strcmp(namespaced_name
, head_name
)) {
1084 switch (deny_delete_current
) {
1088 rp_warning("deleting the current branch");
1091 case DENY_UNCONFIGURED
:
1092 case DENY_UPDATE_INSTEAD
:
1093 if (deny_delete_current
== DENY_UNCONFIGURED
)
1094 refuse_unconfigured_deny_delete_current();
1095 rp_error("refusing to delete the current branch: %s", name
);
1096 return "deletion of the current branch prohibited";
1098 return "Invalid denyDeleteCurrent setting";
1103 if (deny_non_fast_forwards
&& !is_null_oid(new_oid
) &&
1104 !is_null_oid(old_oid
) &&
1105 starts_with(name
, "refs/heads/")) {
1106 struct object
*old_object
, *new_object
;
1107 struct commit
*old_commit
, *new_commit
;
1109 old_object
= parse_object(old_oid
);
1110 new_object
= parse_object(new_oid
);
1112 if (!old_object
|| !new_object
||
1113 old_object
->type
!= OBJ_COMMIT
||
1114 new_object
->type
!= OBJ_COMMIT
) {
1115 error("bad sha1 objects for %s", name
);
1118 old_commit
= (struct commit
*)old_object
;
1119 new_commit
= (struct commit
*)new_object
;
1120 if (!in_merge_bases(old_commit
, new_commit
)) {
1121 rp_error("denying non-fast-forward %s"
1122 " (you should pull first)", name
);
1123 return "non-fast-forward";
1126 if (run_update_hook(cmd
)) {
1127 rp_error("hook declined to update %s", name
);
1128 return "hook declined";
1131 if (is_null_oid(new_oid
)) {
1132 struct strbuf err
= STRBUF_INIT
;
1133 if (!parse_object(old_oid
)) {
1135 if (ref_exists(name
)) {
1136 rp_warning("Allowing deletion of corrupt ref.");
1138 rp_warning("Deleting a non-existent ref.");
1139 cmd
->did_not_exist
= 1;
1142 if (ref_transaction_delete(transaction
,
1146 rp_error("%s", err
.buf
);
1147 strbuf_release(&err
);
1148 return "failed to delete";
1150 strbuf_release(&err
);
1151 return NULL
; /* good */
1154 struct strbuf err
= STRBUF_INIT
;
1155 if (shallow_update
&& si
->shallow_ref
[cmd
->index
] &&
1156 update_shallow_ref(cmd
, si
))
1157 return "shallow error";
1159 if (ref_transaction_update(transaction
,
1164 rp_error("%s", err
.buf
);
1165 strbuf_release(&err
);
1167 return "failed to update ref";
1169 strbuf_release(&err
);
1171 return NULL
; /* good */
1175 static void run_update_post_hook(struct command
*commands
)
1177 struct command
*cmd
;
1178 struct child_process proc
= CHILD_PROCESS_INIT
;
1181 hook
= find_hook("post-update");
1185 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1186 if (cmd
->error_string
|| cmd
->did_not_exist
)
1188 if (!proc
.args
.argc
)
1189 argv_array_push(&proc
.args
, hook
);
1190 argv_array_push(&proc
.args
, cmd
->ref_name
);
1192 if (!proc
.args
.argc
)
1196 proc
.stdout_to_stderr
= 1;
1197 proc
.err
= use_sideband
? -1 : 0;
1199 if (!start_command(&proc
)) {
1201 copy_to_sideband(proc
.err
, -1, NULL
);
1202 finish_command(&proc
);
1206 static void check_aliased_update(struct command
*cmd
, struct string_list
*list
)
1208 struct strbuf buf
= STRBUF_INIT
;
1209 const char *dst_name
;
1210 struct string_list_item
*item
;
1211 struct command
*dst_cmd
;
1214 strbuf_addf(&buf
, "%s%s", get_git_namespace(), cmd
->ref_name
);
1215 dst_name
= resolve_ref_unsafe(buf
.buf
, 0, NULL
, &flag
);
1216 strbuf_release(&buf
);
1218 if (!(flag
& REF_ISSYMREF
))
1222 rp_error("refusing update to broken symref '%s'", cmd
->ref_name
);
1223 cmd
->skip_update
= 1;
1224 cmd
->error_string
= "broken symref";
1227 dst_name
= strip_namespace(dst_name
);
1229 if ((item
= string_list_lookup(list
, dst_name
)) == NULL
)
1232 cmd
->skip_update
= 1;
1234 dst_cmd
= (struct command
*) item
->util
;
1236 if (!oidcmp(&cmd
->old_oid
, &dst_cmd
->old_oid
) &&
1237 !oidcmp(&cmd
->new_oid
, &dst_cmd
->new_oid
))
1240 dst_cmd
->skip_update
= 1;
1242 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1243 " its target '%s' (%s..%s)",
1245 find_unique_abbrev(cmd
->old_oid
.hash
, DEFAULT_ABBREV
),
1246 find_unique_abbrev(cmd
->new_oid
.hash
, DEFAULT_ABBREV
),
1248 find_unique_abbrev(dst_cmd
->old_oid
.hash
, DEFAULT_ABBREV
),
1249 find_unique_abbrev(dst_cmd
->new_oid
.hash
, DEFAULT_ABBREV
));
1251 cmd
->error_string
= dst_cmd
->error_string
=
1252 "inconsistent aliased update";
1255 static void check_aliased_updates(struct command
*commands
)
1257 struct command
*cmd
;
1258 struct string_list ref_list
= STRING_LIST_INIT_NODUP
;
1260 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1261 struct string_list_item
*item
=
1262 string_list_append(&ref_list
, cmd
->ref_name
);
1263 item
->util
= (void *)cmd
;
1265 string_list_sort(&ref_list
);
1267 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1268 if (!cmd
->error_string
)
1269 check_aliased_update(cmd
, &ref_list
);
1272 string_list_clear(&ref_list
, 0);
1275 static int command_singleton_iterator(void *cb_data
, struct object_id
*oid
)
1277 struct command
**cmd_list
= cb_data
;
1278 struct command
*cmd
= *cmd_list
;
1280 if (!cmd
|| is_null_oid(&cmd
->new_oid
))
1281 return -1; /* end of list */
1282 *cmd_list
= NULL
; /* this returns only one */
1283 oidcpy(oid
, &cmd
->new_oid
);
1287 static void set_connectivity_errors(struct command
*commands
,
1288 struct shallow_info
*si
)
1290 struct command
*cmd
;
1292 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1293 struct command
*singleton
= cmd
;
1294 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1296 if (shallow_update
&& si
->shallow_ref
[cmd
->index
])
1297 /* to be checked in update_shallow_ref() */
1300 opt
.env
= tmp_objdir_env(tmp_objdir
);
1301 if (!check_connected(command_singleton_iterator
, &singleton
,
1305 cmd
->error_string
= "missing necessary objects";
1309 struct iterate_data
{
1310 struct command
*cmds
;
1311 struct shallow_info
*si
;
1314 static int iterate_receive_command_list(void *cb_data
, struct object_id
*oid
)
1316 struct iterate_data
*data
= cb_data
;
1317 struct command
**cmd_list
= &data
->cmds
;
1318 struct command
*cmd
= *cmd_list
;
1320 for (; cmd
; cmd
= cmd
->next
) {
1321 if (shallow_update
&& data
->si
->shallow_ref
[cmd
->index
])
1322 /* to be checked in update_shallow_ref() */
1324 if (!is_null_oid(&cmd
->new_oid
) && !cmd
->skip_update
) {
1325 oidcpy(oid
, &cmd
->new_oid
);
1326 *cmd_list
= cmd
->next
;
1331 return -1; /* end of list */
1334 static void reject_updates_to_hidden(struct command
*commands
)
1336 struct strbuf refname_full
= STRBUF_INIT
;
1338 struct command
*cmd
;
1340 strbuf_addstr(&refname_full
, get_git_namespace());
1341 prefix_len
= refname_full
.len
;
1343 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1344 if (cmd
->error_string
)
1347 strbuf_setlen(&refname_full
, prefix_len
);
1348 strbuf_addstr(&refname_full
, cmd
->ref_name
);
1350 if (!ref_is_hidden(cmd
->ref_name
, refname_full
.buf
))
1352 if (is_null_oid(&cmd
->new_oid
))
1353 cmd
->error_string
= "deny deleting a hidden ref";
1355 cmd
->error_string
= "deny updating a hidden ref";
1358 strbuf_release(&refname_full
);
1361 static int should_process_cmd(struct command
*cmd
)
1363 return !cmd
->error_string
&& !cmd
->skip_update
;
1366 static void warn_if_skipped_connectivity_check(struct command
*commands
,
1367 struct shallow_info
*si
)
1369 struct command
*cmd
;
1370 int checked_connectivity
= 1;
1372 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1373 if (should_process_cmd(cmd
) && si
->shallow_ref
[cmd
->index
]) {
1374 error("BUG: connectivity check has not been run on ref %s",
1376 checked_connectivity
= 0;
1379 if (!checked_connectivity
)
1380 die("BUG: connectivity check skipped???");
1383 static void execute_commands_non_atomic(struct command
*commands
,
1384 struct shallow_info
*si
)
1386 struct command
*cmd
;
1387 struct strbuf err
= STRBUF_INIT
;
1389 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1390 if (!should_process_cmd(cmd
))
1393 transaction
= ref_transaction_begin(&err
);
1395 rp_error("%s", err
.buf
);
1397 cmd
->error_string
= "transaction failed to start";
1401 cmd
->error_string
= update(cmd
, si
);
1403 if (!cmd
->error_string
1404 && ref_transaction_commit(transaction
, &err
)) {
1405 rp_error("%s", err
.buf
);
1407 cmd
->error_string
= "failed to update ref";
1409 ref_transaction_free(transaction
);
1411 strbuf_release(&err
);
1414 static void execute_commands_atomic(struct command
*commands
,
1415 struct shallow_info
*si
)
1417 struct command
*cmd
;
1418 struct strbuf err
= STRBUF_INIT
;
1419 const char *reported_error
= "atomic push failure";
1421 transaction
= ref_transaction_begin(&err
);
1423 rp_error("%s", err
.buf
);
1425 reported_error
= "transaction failed to start";
1429 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1430 if (!should_process_cmd(cmd
))
1433 cmd
->error_string
= update(cmd
, si
);
1435 if (cmd
->error_string
)
1439 if (ref_transaction_commit(transaction
, &err
)) {
1440 rp_error("%s", err
.buf
);
1441 reported_error
= "atomic transaction failed";
1447 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1448 if (!cmd
->error_string
)
1449 cmd
->error_string
= reported_error
;
1452 ref_transaction_free(transaction
);
1453 strbuf_release(&err
);
1456 static void execute_commands(struct command
*commands
,
1457 const char *unpacker_error
,
1458 struct shallow_info
*si
,
1459 const struct string_list
*push_options
)
1461 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1462 struct command
*cmd
;
1463 struct iterate_data data
;
1467 if (unpacker_error
) {
1468 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1469 cmd
->error_string
= "unpacker error";
1474 memset(&muxer
, 0, sizeof(muxer
));
1475 muxer
.proc
= copy_to_sideband
;
1477 if (!start_async(&muxer
))
1479 /* ...else, continue without relaying sideband */
1482 data
.cmds
= commands
;
1484 opt
.err_fd
= err_fd
;
1485 opt
.progress
= err_fd
&& !quiet
;
1486 opt
.env
= tmp_objdir_env(tmp_objdir
);
1487 if (check_connected(iterate_receive_command_list
, &data
, &opt
))
1488 set_connectivity_errors(commands
, si
);
1491 finish_async(&muxer
);
1493 reject_updates_to_hidden(commands
);
1495 if (run_receive_hook(commands
, "pre-receive", 0, push_options
)) {
1496 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1497 if (!cmd
->error_string
)
1498 cmd
->error_string
= "pre-receive hook declined";
1504 * Now we'll start writing out refs, which means the objects need
1505 * to be in their final positions so that other processes can see them.
1507 if (tmp_objdir_migrate(tmp_objdir
) < 0) {
1508 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1509 if (!cmd
->error_string
)
1510 cmd
->error_string
= "unable to migrate objects to permanent storage";
1516 check_aliased_updates(commands
);
1518 free(head_name_to_free
);
1519 head_name
= head_name_to_free
= resolve_refdup("HEAD", 0, NULL
, NULL
);
1522 execute_commands_atomic(commands
, si
);
1524 execute_commands_non_atomic(commands
, si
);
1527 warn_if_skipped_connectivity_check(commands
, si
);
1530 static struct command
**queue_command(struct command
**tail
,
1534 struct object_id old_oid
, new_oid
;
1535 struct command
*cmd
;
1536 const char *refname
;
1540 if (parse_oid_hex(line
, &old_oid
, &p
) ||
1542 parse_oid_hex(p
, &new_oid
, &p
) ||
1544 die("protocol error: expected old/new/ref, got '%s'", line
);
1547 reflen
= linelen
- (p
- line
);
1548 FLEX_ALLOC_MEM(cmd
, ref_name
, refname
, reflen
);
1549 oidcpy(&cmd
->old_oid
, &old_oid
);
1550 oidcpy(&cmd
->new_oid
, &new_oid
);
1555 static void queue_commands_from_cert(struct command
**tail
,
1556 struct strbuf
*push_cert
)
1558 const char *boc
, *eoc
;
1561 die("protocol error: got both push certificate and unsigned commands");
1563 boc
= strstr(push_cert
->buf
, "\n\n");
1565 die("malformed push certificate %.*s", 100, push_cert
->buf
);
1568 eoc
= push_cert
->buf
+ parse_signature(push_cert
->buf
, push_cert
->len
);
1571 const char *eol
= memchr(boc
, '\n', eoc
- boc
);
1572 tail
= queue_command(tail
, boc
, eol
? eol
- boc
: eoc
- boc
);
1573 boc
= eol
? eol
+ 1 : eoc
;
1577 static struct command
*read_head_info(struct oid_array
*shallow
)
1579 struct command
*commands
= NULL
;
1580 struct command
**p
= &commands
;
1585 line
= packet_read_line(0, &len
);
1589 if (len
> 8 && starts_with(line
, "shallow ")) {
1590 struct object_id oid
;
1591 if (get_oid_hex(line
+ 8, &oid
))
1592 die("protocol error: expected shallow sha, got '%s'",
1594 oid_array_append(shallow
, &oid
);
1598 linelen
= strlen(line
);
1599 if (linelen
< len
) {
1600 const char *feature_list
= line
+ linelen
+ 1;
1601 if (parse_feature_request(feature_list
, "report-status"))
1603 if (parse_feature_request(feature_list
, "side-band-64k"))
1604 use_sideband
= LARGE_PACKET_MAX
;
1605 if (parse_feature_request(feature_list
, "quiet"))
1607 if (advertise_atomic_push
1608 && parse_feature_request(feature_list
, "atomic"))
1610 if (advertise_push_options
1611 && parse_feature_request(feature_list
, "push-options"))
1612 use_push_options
= 1;
1615 if (!strcmp(line
, "push-cert")) {
1620 len
= packet_read(0, NULL
, NULL
,
1621 certbuf
, sizeof(certbuf
), 0);
1626 if (!strcmp(certbuf
, "push-cert-end\n"))
1627 break; /* end of cert */
1628 strbuf_addstr(&push_cert
, certbuf
);
1636 p
= queue_command(p
, line
, linelen
);
1640 queue_commands_from_cert(p
, &push_cert
);
1645 static void read_push_options(struct string_list
*options
)
1651 line
= packet_read_line(0, &len
);
1656 string_list_append(options
, line
);
1660 static const char *parse_pack_header(struct pack_header
*hdr
)
1662 switch (read_pack_header(0, hdr
)) {
1664 return "eof before pack header was fully read";
1666 case PH_ERROR_PACK_SIGNATURE
:
1667 return "protocol error (pack signature mismatch detected)";
1669 case PH_ERROR_PROTOCOL
:
1670 return "protocol error (pack version unsupported)";
1673 return "unknown error in parse_pack_header";
1680 static const char *pack_lockfile
;
1682 static void push_header_arg(struct argv_array
*args
, struct pack_header
*hdr
)
1684 argv_array_pushf(args
, "--pack_header=%"PRIu32
",%"PRIu32
,
1685 ntohl(hdr
->hdr_version
), ntohl(hdr
->hdr_entries
));
1688 static const char *unpack(int err_fd
, struct shallow_info
*si
)
1690 struct pack_header hdr
;
1691 const char *hdr_err
;
1693 struct child_process child
= CHILD_PROCESS_INIT
;
1694 int fsck_objects
= (receive_fsck_objects
>= 0
1695 ? receive_fsck_objects
1696 : transfer_fsck_objects
>= 0
1697 ? transfer_fsck_objects
1700 hdr_err
= parse_pack_header(&hdr
);
1707 if (si
->nr_ours
|| si
->nr_theirs
) {
1708 alt_shallow_file
= setup_temporary_shallow(si
->shallow
);
1709 argv_array_push(&child
.args
, "--shallow-file");
1710 argv_array_push(&child
.args
, alt_shallow_file
);
1713 tmp_objdir
= tmp_objdir_create();
1717 return "unable to create temporary object directory";
1719 child
.env
= tmp_objdir_env(tmp_objdir
);
1722 * Normally we just pass the tmp_objdir environment to the child
1723 * processes that do the heavy lifting, but we may need to see these
1724 * objects ourselves to set up shallow information.
1726 tmp_objdir_add_as_alternate(tmp_objdir
);
1728 if (ntohl(hdr
.hdr_entries
) < unpack_limit
) {
1729 argv_array_push(&child
.args
, "unpack-objects");
1730 push_header_arg(&child
.args
, &hdr
);
1732 argv_array_push(&child
.args
, "-q");
1734 argv_array_pushf(&child
.args
, "--strict%s",
1735 fsck_msg_types
.buf
);
1737 argv_array_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
1738 (uintmax_t)max_input_size
);
1739 child
.no_stdout
= 1;
1742 status
= run_command(&child
);
1744 return "unpack-objects abnormal exit";
1746 char hostname
[HOST_NAME_MAX
+ 1];
1748 argv_array_pushl(&child
.args
, "index-pack", "--stdin", NULL
);
1749 push_header_arg(&child
.args
, &hdr
);
1751 if (xgethostname(hostname
, sizeof(hostname
)))
1752 xsnprintf(hostname
, sizeof(hostname
), "localhost");
1753 argv_array_pushf(&child
.args
,
1754 "--keep=receive-pack %"PRIuMAX
" on %s",
1755 (uintmax_t)getpid(),
1758 if (!quiet
&& err_fd
)
1759 argv_array_push(&child
.args
, "--show-resolving-progress");
1761 argv_array_push(&child
.args
, "--report-end-of-input");
1763 argv_array_pushf(&child
.args
, "--strict%s",
1764 fsck_msg_types
.buf
);
1766 argv_array_push(&child
.args
, "--fix-thin");
1768 argv_array_pushf(&child
.args
, "--max-input-size=%"PRIuMAX
,
1769 (uintmax_t)max_input_size
);
1773 status
= start_command(&child
);
1775 return "index-pack fork failed";
1776 pack_lockfile
= index_pack_lockfile(child
.out
);
1778 status
= finish_command(&child
);
1780 return "index-pack abnormal exit";
1781 reprepare_packed_git(the_repository
);
1786 static const char *unpack_with_sideband(struct shallow_info
*si
)
1792 return unpack(0, si
);
1794 use_keepalive
= KEEPALIVE_AFTER_NUL
;
1795 memset(&muxer
, 0, sizeof(muxer
));
1796 muxer
.proc
= copy_to_sideband
;
1798 if (start_async(&muxer
))
1801 ret
= unpack(muxer
.in
, si
);
1803 finish_async(&muxer
);
1807 static void prepare_shallow_update(struct command
*commands
,
1808 struct shallow_info
*si
)
1810 int i
, j
, k
, bitmap_size
= DIV_ROUND_UP(si
->ref
->nr
, 32);
1812 ALLOC_ARRAY(si
->used_shallow
, si
->shallow
->nr
);
1813 assign_shallow_commits_to_refs(si
, si
->used_shallow
, NULL
);
1815 si
->need_reachability_test
=
1816 xcalloc(si
->shallow
->nr
, sizeof(*si
->need_reachability_test
));
1818 xcalloc(si
->shallow
->nr
, sizeof(*si
->reachable
));
1819 si
->shallow_ref
= xcalloc(si
->ref
->nr
, sizeof(*si
->shallow_ref
));
1821 for (i
= 0; i
< si
->nr_ours
; i
++)
1822 si
->need_reachability_test
[si
->ours
[i
]] = 1;
1824 for (i
= 0; i
< si
->shallow
->nr
; i
++) {
1825 if (!si
->used_shallow
[i
])
1827 for (j
= 0; j
< bitmap_size
; j
++) {
1828 if (!si
->used_shallow
[i
][j
])
1830 si
->need_reachability_test
[i
]++;
1831 for (k
= 0; k
< 32; k
++)
1832 if (si
->used_shallow
[i
][j
] & (1U << k
))
1833 si
->shallow_ref
[j
* 32 + k
]++;
1837 * true for those associated with some refs and belong
1838 * in "ours" list aka "step 7 not done yet"
1840 si
->need_reachability_test
[i
] =
1841 si
->need_reachability_test
[i
] > 1;
1845 * keep hooks happy by forcing a temporary shallow file via
1846 * env variable because we can't add --shallow-file to every
1847 * command. check_everything_connected() will be done with
1848 * true .git/shallow though.
1850 setenv(GIT_SHALLOW_FILE_ENVIRONMENT
, alt_shallow_file
, 1);
1853 static void update_shallow_info(struct command
*commands
,
1854 struct shallow_info
*si
,
1855 struct oid_array
*ref
)
1857 struct command
*cmd
;
1859 remove_nonexistent_theirs_shallow(si
);
1860 if (!si
->nr_ours
&& !si
->nr_theirs
) {
1865 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1866 if (is_null_oid(&cmd
->new_oid
))
1868 oid_array_append(ref
, &cmd
->new_oid
);
1869 cmd
->index
= ref
->nr
- 1;
1873 if (shallow_update
) {
1874 prepare_shallow_update(commands
, si
);
1878 ALLOC_ARRAY(ref_status
, ref
->nr
);
1879 assign_shallow_commits_to_refs(si
, NULL
, ref_status
);
1880 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1881 if (is_null_oid(&cmd
->new_oid
))
1883 if (ref_status
[cmd
->index
]) {
1884 cmd
->error_string
= "shallow update not allowed";
1885 cmd
->skip_update
= 1;
1891 static void report(struct command
*commands
, const char *unpack_status
)
1893 struct command
*cmd
;
1894 struct strbuf buf
= STRBUF_INIT
;
1896 packet_buf_write(&buf
, "unpack %s\n",
1897 unpack_status
? unpack_status
: "ok");
1898 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1899 if (!cmd
->error_string
)
1900 packet_buf_write(&buf
, "ok %s\n",
1903 packet_buf_write(&buf
, "ng %s %s\n",
1904 cmd
->ref_name
, cmd
->error_string
);
1906 packet_buf_flush(&buf
);
1909 send_sideband(1, 1, buf
.buf
, buf
.len
, use_sideband
);
1911 write_or_die(1, buf
.buf
, buf
.len
);
1912 strbuf_release(&buf
);
1915 static int delete_only(struct command
*commands
)
1917 struct command
*cmd
;
1918 for (cmd
= commands
; cmd
; cmd
= cmd
->next
) {
1919 if (!is_null_oid(&cmd
->new_oid
))
1925 int cmd_receive_pack(int argc
, const char **argv
, const char *prefix
)
1927 int advertise_refs
= 0;
1928 struct command
*commands
;
1929 struct oid_array shallow
= OID_ARRAY_INIT
;
1930 struct oid_array ref
= OID_ARRAY_INIT
;
1931 struct shallow_info si
;
1933 struct option options
[] = {
1934 OPT__QUIET(&quiet
, N_("quiet")),
1935 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc
, NULL
),
1936 OPT_HIDDEN_BOOL(0, "advertise-refs", &advertise_refs
, NULL
),
1937 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin
, NULL
),
1941 packet_trace_identity("receive-pack");
1943 argc
= parse_options(argc
, argv
, prefix
, options
, receive_pack_usage
, 0);
1946 usage_msg_opt(_("Too many arguments."), receive_pack_usage
, options
);
1948 usage_msg_opt(_("You must specify a directory."), receive_pack_usage
, options
);
1950 service_dir
= argv
[0];
1954 if (!enter_repo(service_dir
, 0))
1955 die("'%s' does not appear to be a git repository", service_dir
);
1957 git_config(receive_pack_config
, NULL
);
1958 if (cert_nonce_seed
)
1959 push_cert_nonce
= prepare_push_cert_nonce(service_dir
, time(NULL
));
1961 if (0 <= transfer_unpack_limit
)
1962 unpack_limit
= transfer_unpack_limit
;
1963 else if (0 <= receive_unpack_limit
)
1964 unpack_limit
= receive_unpack_limit
;
1966 switch (determine_protocol_version_server()) {
1969 * v1 is just the original protocol with a version string,
1970 * so just fall through after writing the version string.
1972 if (advertise_refs
|| !stateless_rpc
)
1973 packet_write_fmt(1, "version 1\n");
1978 case protocol_unknown_version
:
1979 BUG("unknown protocol version");
1982 if (advertise_refs
|| !stateless_rpc
) {
1988 if ((commands
= read_head_info(&shallow
)) != NULL
) {
1989 const char *unpack_status
= NULL
;
1990 struct string_list push_options
= STRING_LIST_INIT_DUP
;
1992 if (use_push_options
)
1993 read_push_options(&push_options
);
1994 if (!check_cert_push_options(&push_options
)) {
1995 struct command
*cmd
;
1996 for (cmd
= commands
; cmd
; cmd
= cmd
->next
)
1997 cmd
->error_string
= "inconsistent push options";
2000 prepare_shallow_info(&si
, &shallow
);
2001 if (!si
.nr_ours
&& !si
.nr_theirs
)
2003 if (!delete_only(commands
)) {
2004 unpack_status
= unpack_with_sideband(&si
);
2005 update_shallow_info(commands
, &si
, &ref
);
2007 use_keepalive
= KEEPALIVE_ALWAYS
;
2008 execute_commands(commands
, unpack_status
, &si
,
2011 unlink_or_warn(pack_lockfile
);
2013 report(commands
, unpack_status
);
2014 run_receive_hook(commands
, "post-receive", 1,
2016 run_update_post_hook(commands
);
2017 string_list_clear(&push_options
, 0);
2019 const char *argv_gc_auto
[] = {
2020 "gc", "--auto", "--quiet", NULL
,
2022 struct child_process proc
= CHILD_PROCESS_INIT
;
2025 proc
.stdout_to_stderr
= 1;
2026 proc
.err
= use_sideband
? -1 : 0;
2028 proc
.argv
= argv_gc_auto
;
2030 close_all_packs(the_repository
->objects
);
2031 if (!start_command(&proc
)) {
2033 copy_to_sideband(proc
.err
, -1, NULL
);
2034 finish_command(&proc
);
2037 if (auto_update_server_info
)
2038 update_server_info(0);
2039 clear_shallow_info(&si
);
2043 oid_array_clear(&shallow
);
2044 oid_array_clear(&ref
);
2045 free((void *)push_cert_nonce
);