11800cda2efa1944c798d32838d3da2b5b798aa0
1#include "builtin.h"
2#include "lockfile.h"
3#include "pack.h"
4#include "refs.h"
5#include "pkt-line.h"
6#include "sideband.h"
7#include "run-command.h"
8#include "exec_cmd.h"
9#include "commit.h"
10#include "object.h"
11#include "remote.h"
12#include "connect.h"
13#include "transport.h"
14#include "string-list.h"
15#include "sha1-array.h"
16#include "connected.h"
17#include "argv-array.h"
18#include "version.h"
19#include "tag.h"
20#include "gpg-interface.h"
21#include "sigchain.h"
22static const char receive_pack_usage[] = "git receive-pack <git-dir>";
24enum deny_action {
26 DENY_UNCONFIGURED,
27 DENY_IGNORE,
28 DENY_WARN,
29 DENY_REFUSE,
30 DENY_UPDATE_INSTEAD
31};
32static int deny_deletes;
34static int deny_non_fast_forwards;
35static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
36static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
37static int receive_fsck_objects = -1;
38static int transfer_fsck_objects = -1;
39static int receive_unpack_limit = -1;
40static int transfer_unpack_limit = -1;
41static int unpack_limit = 100;
42static int report_status;
43static int use_sideband;
44static int quiet;
45static int prefer_ofs_delta = 1;
46static int auto_update_server_info;
47static int auto_gc = 1;
48static int fix_thin = 1;
49static int stateless_rpc;
50static const char *service_dir;
51static const char *head_name;
52static void *head_name_to_free;
53static int sent_capabilities;
54static int shallow_update;
55static const char *alt_shallow_file;
56static struct strbuf push_cert = STRBUF_INIT;
57static unsigned char push_cert_sha1[20];
58static struct signature_check sigcheck;
59static const char *push_cert_nonce;
60static const char *cert_nonce_seed;
61static const char *NONCE_UNSOLICITED = "UNSOLICITED";
63static const char *NONCE_BAD = "BAD";
64static const char *NONCE_MISSING = "MISSING";
65static const char *NONCE_OK = "OK";
66static const char *NONCE_SLOP = "SLOP";
67static const char *nonce_status;
68static long nonce_stamp_slop;
69static unsigned long nonce_stamp_slop_limit;
70static enum deny_action parse_deny_action(const char *var, const char *value)
72{
73 if (value) {
74 if (!strcasecmp(value, "ignore"))
75 return DENY_IGNORE;
76 if (!strcasecmp(value, "warn"))
77 return DENY_WARN;
78 if (!strcasecmp(value, "refuse"))
79 return DENY_REFUSE;
80 if (!strcasecmp(value, "updateinstead"))
81 return DENY_UPDATE_INSTEAD;
82 }
83 if (git_config_bool(var, value))
84 return DENY_REFUSE;
85 return DENY_IGNORE;
86}
87static int receive_pack_config(const char *var, const char *value, void *cb)
89{
90 int status = parse_hide_refs_config(var, value, "receive");
91 if (status)
93 return status;
94 if (strcmp(var, "receive.denydeletes") == 0) {
96 deny_deletes = git_config_bool(var, value);
97 return 0;
98 }
99 if (strcmp(var, "receive.denynonfastforwards") == 0) {
101 deny_non_fast_forwards = git_config_bool(var, value);
102 return 0;
103 }
104 if (strcmp(var, "receive.unpacklimit") == 0) {
106 receive_unpack_limit = git_config_int(var, value);
107 return 0;
108 }
109 if (strcmp(var, "transfer.unpacklimit") == 0) {
111 transfer_unpack_limit = git_config_int(var, value);
112 return 0;
113 }
114 if (strcmp(var, "receive.fsckobjects") == 0) {
116 receive_fsck_objects = git_config_bool(var, value);
117 return 0;
118 }
119 if (strcmp(var, "transfer.fsckobjects") == 0) {
121 transfer_fsck_objects = git_config_bool(var, value);
122 return 0;
123 }
124 if (!strcmp(var, "receive.denycurrentbranch")) {
126 deny_current_branch = parse_deny_action(var, value);
127 return 0;
128 }
129 if (strcmp(var, "receive.denydeletecurrent") == 0) {
131 deny_delete_current = parse_deny_action(var, value);
132 return 0;
133 }
134 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
136 prefer_ofs_delta = git_config_bool(var, value);
137 return 0;
138 }
139 if (strcmp(var, "receive.updateserverinfo") == 0) {
141 auto_update_server_info = git_config_bool(var, value);
142 return 0;
143 }
144 if (strcmp(var, "receive.autogc") == 0) {
146 auto_gc = git_config_bool(var, value);
147 return 0;
148 }
149 if (strcmp(var, "receive.shallowupdate") == 0) {
151 shallow_update = git_config_bool(var, value);
152 return 0;
153 }
154 if (strcmp(var, "receive.certnonceseed") == 0)
156 return git_config_string(&cert_nonce_seed, var, value);
157 if (strcmp(var, "receive.certnonceslop") == 0) {
159 nonce_stamp_slop_limit = git_config_ulong(var, value);
160 return 0;
161 }
162 return git_default_config(var, value, cb);
164}
165static void show_ref(const char *path, const unsigned char *sha1)
167{
168 if (ref_is_hidden(path))
169 return;
170 if (sent_capabilities) {
172 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
173 } else {
174 struct strbuf cap = STRBUF_INIT;
175 strbuf_addstr(&cap,
177 "report-status delete-refs side-band-64k quiet");
178 if (prefer_ofs_delta)
179 strbuf_addstr(&cap, " ofs-delta");
180 if (push_cert_nonce)
181 strbuf_addf(&cap, " push-cert=%s", push_cert_nonce);
182 strbuf_addf(&cap, " agent=%s", git_user_agent_sanitized());
183 packet_write(1, "%s %s%c%s\n",
184 sha1_to_hex(sha1), path, 0, cap.buf);
185 strbuf_release(&cap);
186 sent_capabilities = 1;
187 }
188}
189static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
191{
192 path = strip_namespace(path);
193 /*
194 * Advertise refs outside our current namespace as ".have"
195 * refs, so that the client can use them to minimize data
196 * transfer but will otherwise ignore them. This happens to
197 * cover ".have" that are thrown in by add_one_alternate_ref()
198 * to mark histories that are complete in our alternates as
199 * well.
200 */
201 if (!path)
202 path = ".have";
203 show_ref(path, sha1);
204 return 0;
205}
206static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
208{
209 show_ref(".have", sha1);
210}
211static void collect_one_alternate_ref(const struct ref *ref, void *data)
213{
214 struct sha1_array *sa = data;
215 sha1_array_append(sa, ref->old_sha1);
216}
217static void write_head_info(void)
219{
220 struct sha1_array sa = SHA1_ARRAY_INIT;
221 for_each_alternate_ref(collect_one_alternate_ref, &sa);
222 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
223 sha1_array_clear(&sa);
224 for_each_ref(show_ref_cb, NULL);
225 if (!sent_capabilities)
226 show_ref("capabilities^{}", null_sha1);
227 advertise_shallow_grafts(1);
229 /* EOF */
231 packet_flush(1);
232}
233struct command {
235 struct command *next;
236 const char *error_string;
237 unsigned int skip_update:1,
238 did_not_exist:1;
239 int index;
240 unsigned char old_sha1[20];
241 unsigned char new_sha1[20];
242 char ref_name[FLEX_ARRAY]; /* more */
243};
244static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
246static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
247static void report_message(const char *prefix, const char *err, va_list params)
249{
250 int sz = strlen(prefix);
251 char msg[4096];
252 strncpy(msg, prefix, sz);
254 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
255 if (sz > (sizeof(msg) - 1))
256 sz = sizeof(msg) - 1;
257 msg[sz++] = '\n';
258 if (use_sideband)
260 send_sideband(1, 2, msg, sz, use_sideband);
261 else
262 xwrite(2, msg, sz);
263}
264static void rp_warning(const char *err, ...)
266{
267 va_list params;
268 va_start(params, err);
269 report_message("warning: ", err, params);
270 va_end(params);
271}
272static void rp_error(const char *err, ...)
274{
275 va_list params;
276 va_start(params, err);
277 report_message("error: ", err, params);
278 va_end(params);
279}
280static int copy_to_sideband(int in, int out, void *arg)
282{
283 char data[128];
284 while (1) {
285 ssize_t sz = xread(in, data, sizeof(data));
286 if (sz <= 0)
287 break;
288 send_sideband(1, 2, data, sz, use_sideband);
289 }
290 close(in);
291 return 0;
292}
293#define HMAC_BLOCK_SIZE 64
295static void hmac_sha1(unsigned char *out,
297 const char *key_in, size_t key_len,
298 const char *text, size_t text_len)
299{
300 unsigned char key[HMAC_BLOCK_SIZE];
301 unsigned char k_ipad[HMAC_BLOCK_SIZE];
302 unsigned char k_opad[HMAC_BLOCK_SIZE];
303 int i;
304 git_SHA_CTX ctx;
305 /* RFC 2104 2. (1) */
307 memset(key, '\0', HMAC_BLOCK_SIZE);
308 if (HMAC_BLOCK_SIZE < key_len) {
309 git_SHA1_Init(&ctx);
310 git_SHA1_Update(&ctx, key_in, key_len);
311 git_SHA1_Final(key, &ctx);
312 } else {
313 memcpy(key, key_in, key_len);
314 }
315 /* RFC 2104 2. (2) & (5) */
317 for (i = 0; i < sizeof(key); i++) {
318 k_ipad[i] = key[i] ^ 0x36;
319 k_opad[i] = key[i] ^ 0x5c;
320 }
321 /* RFC 2104 2. (3) & (4) */
323 git_SHA1_Init(&ctx);
324 git_SHA1_Update(&ctx, k_ipad, sizeof(k_ipad));
325 git_SHA1_Update(&ctx, text, text_len);
326 git_SHA1_Final(out, &ctx);
327 /* RFC 2104 2. (6) & (7) */
329 git_SHA1_Init(&ctx);
330 git_SHA1_Update(&ctx, k_opad, sizeof(k_opad));
331 git_SHA1_Update(&ctx, out, 20);
332 git_SHA1_Final(out, &ctx);
333}
334static char *prepare_push_cert_nonce(const char *path, unsigned long stamp)
336{
337 struct strbuf buf = STRBUF_INIT;
338 unsigned char sha1[20];
339 strbuf_addf(&buf, "%s:%lu", path, stamp);
341 hmac_sha1(sha1, buf.buf, buf.len, cert_nonce_seed, strlen(cert_nonce_seed));;
342 strbuf_release(&buf);
343 /* RFC 2104 5. HMAC-SHA1-80 */
345 strbuf_addf(&buf, "%lu-%.*s", stamp, 20, sha1_to_hex(sha1));
346 return strbuf_detach(&buf, NULL);
347}
348/*
350 * NEEDSWORK: reuse find_commit_header() from jk/commit-author-parsing
351 * after dropping "_commit" from its name and possibly moving it out
352 * of commit.c
353 */
354static char *find_header(const char *msg, size_t len, const char *key)
355{
356 int key_len = strlen(key);
357 const char *line = msg;
358 while (line && line < msg + len) {
360 const char *eol = strchrnul(line, '\n');
361 if ((msg + len <= eol) || line == eol)
363 return NULL;
364 if (line + key_len < eol &&
365 !memcmp(line, key, key_len) && line[key_len] == ' ') {
366 int offset = key_len + 1;
367 return xmemdupz(line + offset, (eol - line) - offset);
368 }
369 line = *eol ? eol + 1 : NULL;
370 }
371 return NULL;
372}
373static const char *check_nonce(const char *buf, size_t len)
375{
376 char *nonce = find_header(buf, len, "nonce");
377 unsigned long stamp, ostamp;
378 char *bohmac, *expect = NULL;
379 const char *retval = NONCE_BAD;
380 if (!nonce) {
382 retval = NONCE_MISSING;
383 goto leave;
384 } else if (!push_cert_nonce) {
385 retval = NONCE_UNSOLICITED;
386 goto leave;
387 } else if (!strcmp(push_cert_nonce, nonce)) {
388 retval = NONCE_OK;
389 goto leave;
390 }
391 if (!stateless_rpc) {
393 /* returned nonce MUST match what we gave out earlier */
394 retval = NONCE_BAD;
395 goto leave;
396 }
397 /*
399 * In stateless mode, we may be receiving a nonce issued by
400 * another instance of the server that serving the same
401 * repository, and the timestamps may not match, but the
402 * nonce-seed and dir should match, so we can recompute and
403 * report the time slop.
404 *
405 * In addition, when a nonce issued by another instance has
406 * timestamp within receive.certnonceslop seconds, we pretend
407 * as if we issued that nonce when reporting to the hook.
408 */
409 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
411 if (*nonce <= '0' || '9' < *nonce) {
412 retval = NONCE_BAD;
413 goto leave;
414 }
415 stamp = strtoul(nonce, &bohmac, 10);
416 if (bohmac == nonce || bohmac[0] != '-') {
417 retval = NONCE_BAD;
418 goto leave;
419 }
420 expect = prepare_push_cert_nonce(service_dir, stamp);
422 if (strcmp(expect, nonce)) {
423 /* Not what we would have signed earlier */
424 retval = NONCE_BAD;
425 goto leave;
426 }
427 /*
429 * By how many seconds is this nonce stale? Negative value
430 * would mean it was issued by another server with its clock
431 * skewed in the future.
432 */
433 ostamp = strtoul(push_cert_nonce, NULL, 10);
434 nonce_stamp_slop = (long)ostamp - (long)stamp;
435 if (nonce_stamp_slop_limit &&
437 abs(nonce_stamp_slop) <= nonce_stamp_slop_limit) {
438 /*
439 * Pretend as if the received nonce (which passes the
440 * HMAC check, so it is not a forged by third-party)
441 * is what we issued.
442 */
443 free((void *)push_cert_nonce);
444 push_cert_nonce = xstrdup(nonce);
445 retval = NONCE_OK;
446 } else {
447 retval = NONCE_SLOP;
448 }
449leave:
451 free(nonce);
452 free(expect);
453 return retval;
454}
455static void prepare_push_cert_sha1(struct child_process *proc)
457{
458 static int already_done;
459 if (!push_cert.len)
461 return;
462 if (!already_done) {
464 struct strbuf gpg_output = STRBUF_INIT;
465 struct strbuf gpg_status = STRBUF_INIT;
466 int bogs /* beginning_of_gpg_sig */;
467 already_done = 1;
469 if (write_sha1_file(push_cert.buf, push_cert.len, "blob", push_cert_sha1))
470 hashclr(push_cert_sha1);
471 memset(&sigcheck, '\0', sizeof(sigcheck));
473 sigcheck.result = 'N';
474 bogs = parse_signature(push_cert.buf, push_cert.len);
476 if (verify_signed_buffer(push_cert.buf, bogs,
477 push_cert.buf + bogs, push_cert.len - bogs,
478 &gpg_output, &gpg_status) < 0) {
479 ; /* error running gpg */
480 } else {
481 sigcheck.payload = push_cert.buf;
482 sigcheck.gpg_output = gpg_output.buf;
483 sigcheck.gpg_status = gpg_status.buf;
484 parse_gpg_output(&sigcheck);
485 }
486 strbuf_release(&gpg_output);
488 strbuf_release(&gpg_status);
489 nonce_status = check_nonce(push_cert.buf, bogs);
490 }
491 if (!is_null_sha1(push_cert_sha1)) {
492 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT=%s",
493 sha1_to_hex(push_cert_sha1));
494 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_SIGNER=%s",
495 sigcheck.signer ? sigcheck.signer : "");
496 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_KEY=%s",
497 sigcheck.key ? sigcheck.key : "");
498 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_STATUS=%c",
499 sigcheck.result);
500 if (push_cert_nonce) {
501 argv_array_pushf(&proc->env_array,
502 "GIT_PUSH_CERT_NONCE=%s",
503 push_cert_nonce);
504 argv_array_pushf(&proc->env_array,
505 "GIT_PUSH_CERT_NONCE_STATUS=%s",
506 nonce_status);
507 if (nonce_status == NONCE_SLOP)
508 argv_array_pushf(&proc->env_array,
509 "GIT_PUSH_CERT_NONCE_SLOP=%ld",
510 nonce_stamp_slop);
511 }
512 }
513}
514typedef int (*feed_fn)(void *, const char **, size_t *);
516static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
517{
518 struct child_process proc = CHILD_PROCESS_INIT;
519 struct async muxer;
520 const char *argv[2];
521 int code;
522 argv[0] = find_hook(hook_name);
524 if (!argv[0])
525 return 0;
526 argv[1] = NULL;
528 proc.argv = argv;
530 proc.in = -1;
531 proc.stdout_to_stderr = 1;
532 if (use_sideband) {
534 memset(&muxer, 0, sizeof(muxer));
535 muxer.proc = copy_to_sideband;
536 muxer.in = -1;
537 code = start_async(&muxer);
538 if (code)
539 return code;
540 proc.err = muxer.in;
541 }
542 prepare_push_cert_sha1(&proc);
544 code = start_command(&proc);
546 if (code) {
547 if (use_sideband)
548 finish_async(&muxer);
549 return code;
550 }
551 sigchain_push(SIGPIPE, SIG_IGN);
553 while (1) {
555 const char *buf;
556 size_t n;
557 if (feed(feed_state, &buf, &n))
558 break;
559 if (write_in_full(proc.in, buf, n) != n)
560 break;
561 }
562 close(proc.in);
563 if (use_sideband)
564 finish_async(&muxer);
565 sigchain_pop(SIGPIPE);
567 return finish_command(&proc);
569}
570struct receive_hook_feed_state {
572 struct command *cmd;
573 int skip_broken;
574 struct strbuf buf;
575};
576static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
578{
579 struct receive_hook_feed_state *state = state_;
580 struct command *cmd = state->cmd;
581 while (cmd &&
583 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
584 cmd = cmd->next;
585 if (!cmd)
586 return -1; /* EOF */
587 strbuf_reset(&state->buf);
588 strbuf_addf(&state->buf, "%s %s %s\n",
589 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
590 cmd->ref_name);
591 state->cmd = cmd->next;
592 if (bufp) {
593 *bufp = state->buf.buf;
594 *sizep = state->buf.len;
595 }
596 return 0;
597}
598static int run_receive_hook(struct command *commands, const char *hook_name,
600 int skip_broken)
601{
602 struct receive_hook_feed_state state;
603 int status;
604 strbuf_init(&state.buf, 0);
606 state.cmd = commands;
607 state.skip_broken = skip_broken;
608 if (feed_receive_hook(&state, NULL, NULL))
609 return 0;
610 state.cmd = commands;
611 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
612 strbuf_release(&state.buf);
613 return status;
614}
615static int run_update_hook(struct command *cmd)
617{
618 const char *argv[5];
619 struct child_process proc = CHILD_PROCESS_INIT;
620 int code;
621 argv[0] = find_hook("update");
623 if (!argv[0])
624 return 0;
625 argv[1] = cmd->ref_name;
627 argv[2] = sha1_to_hex(cmd->old_sha1);
628 argv[3] = sha1_to_hex(cmd->new_sha1);
629 argv[4] = NULL;
630 proc.no_stdin = 1;
632 proc.stdout_to_stderr = 1;
633 proc.err = use_sideband ? -1 : 0;
634 proc.argv = argv;
635 code = start_command(&proc);
637 if (code)
638 return code;
639 if (use_sideband)
640 copy_to_sideband(proc.err, -1, NULL);
641 return finish_command(&proc);
642}
643static int is_ref_checked_out(const char *ref)
645{
646 if (is_bare_repository())
647 return 0;
648 if (!head_name)
650 return 0;
651 return !strcmp(head_name, ref);
652}
653static char *refuse_unconfigured_deny_msg[] = {
655 "By default, updating the current branch in a non-bare repository",
656 "is denied, because it will make the index and work tree inconsistent",
657 "with what you pushed, and will require 'git reset --hard' to match",
658 "the work tree to HEAD.",
659 "",
660 "You can set 'receive.denyCurrentBranch' configuration variable to",
661 "'ignore' or 'warn' in the remote repository to allow pushing into",
662 "its current branch; however, this is not recommended unless you",
663 "arranged to update its work tree to match what you pushed in some",
664 "other way.",
665 "",
666 "To squelch this message and still keep the default behaviour, set",
667 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
668};
669static void refuse_unconfigured_deny(void)
671{
672 int i;
673 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
674 rp_error("%s", refuse_unconfigured_deny_msg[i]);
675}
676static char *refuse_unconfigured_deny_delete_current_msg[] = {
678 "By default, deleting the current branch is denied, because the next",
679 "'git clone' won't result in any file checked out, causing confusion.",
680 "",
681 "You can set 'receive.denyDeleteCurrent' configuration variable to",
682 "'warn' or 'ignore' in the remote repository to allow deleting the",
683 "current branch, with or without a warning message.",
684 "",
685 "To squelch this message, you can set it to 'refuse'."
686};
687static void refuse_unconfigured_deny_delete_current(void)
689{
690 int i;
691 for (i = 0;
692 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
693 i++)
694 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
695}
696static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
698static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
699{
700 static struct lock_file shallow_lock;
701 struct sha1_array extra = SHA1_ARRAY_INIT;
702 const char *alt_file;
703 uint32_t mask = 1 << (cmd->index % 32);
704 int i;
705 trace_printf_key(&trace_shallow,
707 "shallow: update_shallow_ref %s\n", cmd->ref_name);
708 for (i = 0; i < si->shallow->nr; i++)
709 if (si->used_shallow[i] &&
710 (si->used_shallow[i][cmd->index / 32] & mask) &&
711 !delayed_reachability_test(si, i))
712 sha1_array_append(&extra, si->shallow->sha1[i]);
713 setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
715 if (check_shallow_connected(command_singleton_iterator,
716 0, cmd, alt_file)) {
717 rollback_lock_file(&shallow_lock);
718 sha1_array_clear(&extra);
719 return -1;
720 }
721 commit_lock_file(&shallow_lock);
723 /*
725 * Make sure setup_alternate_shallow() for the next ref does
726 * not lose these new roots..
727 */
728 for (i = 0; i < extra.nr; i++)
729 register_shallow(extra.sha1[i]);
730 si->shallow_ref[cmd->index] = 0;
732 sha1_array_clear(&extra);
733 return 0;
734}
735static const char *push_to_deploy(unsigned char *sha1,
737 struct argv_array *env,
738 const char *work_tree)
739{
740 const char *update_refresh[] = {
741 "update-index", "-q", "--ignore-submodules", "--refresh", NULL
742 };
743 const char *diff_files[] = {
744 "diff-files", "--quiet", "--ignore-submodules", "--", NULL
745 };
746 const char *diff_index[] = {
747 "diff-index", "--quiet", "--cached", "--ignore-submodules",
748 "HEAD", "--", NULL
749 };
750 const char *read_tree[] = {
751 "read-tree", "-u", "-m", NULL, NULL
752 };
753 struct child_process child = CHILD_PROCESS_INIT;
754 child.argv = update_refresh;
756 child.env = env->argv;
757 child.dir = work_tree;
758 child.no_stdin = 1;
759 child.stdout_to_stderr = 1;
760 child.git_cmd = 1;
761 if (run_command(&child))
762 return "Up-to-date check failed";
763 /* run_command() does not clean up completely; reinitialize */
765 child_process_init(&child);
766 child.argv = diff_files;
767 child.env = env->argv;
768 child.dir = work_tree;
769 child.no_stdin = 1;
770 child.stdout_to_stderr = 1;
771 child.git_cmd = 1;
772 if (run_command(&child))
773 return "Working directory has unstaged changes";
774 child_process_init(&child);
776 child.argv = diff_index;
777 child.env = env->argv;
778 child.no_stdin = 1;
779 child.no_stdout = 1;
780 child.stdout_to_stderr = 0;
781 child.git_cmd = 1;
782 if (run_command(&child))
783 return "Working directory has staged changes";
784 read_tree[3] = sha1_to_hex(sha1);
786 child_process_init(&child);
787 child.argv = read_tree;
788 child.env = env->argv;
789 child.dir = work_tree;
790 child.no_stdin = 1;
791 child.no_stdout = 1;
792 child.stdout_to_stderr = 0;
793 child.git_cmd = 1;
794 if (run_command(&child))
795 return "Could not update working tree to new HEAD";
796 return NULL;
798}
799static const char *update_worktree(unsigned char *sha1)
801{
802 const char *retval;
803 const char *work_tree = git_work_tree_cfg ? git_work_tree_cfg : "..";
804 struct argv_array env = ARGV_ARRAY_INIT;
805 if (is_bare_repository())
807 return "denyCurrentBranch = updateInstead needs a worktree";
808 argv_array_pushf(&env, "GIT_DIR=%s", absolute_path(get_git_dir()));
810 retval = push_to_deploy(sha1, &env, work_tree);
812 argv_array_clear(&env);
814 return retval;
815}
816static const char *update(struct command *cmd, struct shallow_info *si)
818{
819 const char *name = cmd->ref_name;
820 struct strbuf namespaced_name_buf = STRBUF_INIT;
821 const char *namespaced_name, *ret;
822 unsigned char *old_sha1 = cmd->old_sha1;
823 unsigned char *new_sha1 = cmd->new_sha1;
824 /* only refs/... are allowed */
826 if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
827 rp_error("refusing to create funny ref '%s' remotely", name);
828 return "funny refname";
829 }
830 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
832 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
833 if (is_ref_checked_out(namespaced_name)) {
835 switch (deny_current_branch) {
836 case DENY_IGNORE:
837 break;
838 case DENY_WARN:
839 rp_warning("updating the current branch");
840 break;
841 case DENY_REFUSE:
842 case DENY_UNCONFIGURED:
843 rp_error("refusing to update checked out branch: %s", name);
844 if (deny_current_branch == DENY_UNCONFIGURED)
845 refuse_unconfigured_deny();
846 return "branch is currently checked out";
847 case DENY_UPDATE_INSTEAD:
848 ret = update_worktree(new_sha1);
849 if (ret)
850 return ret;
851 break;
852 }
853 }
854 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
856 error("unpack should have generated %s, "
857 "but I can't find it!", sha1_to_hex(new_sha1));
858 return "bad pack";
859 }
860 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
862 if (deny_deletes && starts_with(name, "refs/heads/")) {
863 rp_error("denying ref deletion for %s", name);
864 return "deletion prohibited";
865 }
866 if (!strcmp(namespaced_name, head_name)) {
868 switch (deny_delete_current) {
869 case DENY_IGNORE:
870 break;
871 case DENY_WARN:
872 rp_warning("deleting the current branch");
873 break;
874 case DENY_REFUSE:
875 case DENY_UNCONFIGURED:
876 case DENY_UPDATE_INSTEAD:
877 if (deny_delete_current == DENY_UNCONFIGURED)
878 refuse_unconfigured_deny_delete_current();
879 rp_error("refusing to delete the current branch: %s", name);
880 return "deletion of the current branch prohibited";
881 default:
882 return "Invalid denyDeleteCurrent setting";
883 }
884 }
885 }
886 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
888 !is_null_sha1(old_sha1) &&
889 starts_with(name, "refs/heads/")) {
890 struct object *old_object, *new_object;
891 struct commit *old_commit, *new_commit;
892 old_object = parse_object(old_sha1);
894 new_object = parse_object(new_sha1);
895 if (!old_object || !new_object ||
897 old_object->type != OBJ_COMMIT ||
898 new_object->type != OBJ_COMMIT) {
899 error("bad sha1 objects for %s", name);
900 return "bad ref";
901 }
902 old_commit = (struct commit *)old_object;
903 new_commit = (struct commit *)new_object;
904 if (!in_merge_bases(old_commit, new_commit)) {
905 rp_error("denying non-fast-forward %s"
906 " (you should pull first)", name);
907 return "non-fast-forward";
908 }
909 }
910 if (run_update_hook(cmd)) {
911 rp_error("hook declined to update %s", name);
912 return "hook declined";
913 }
914 if (is_null_sha1(new_sha1)) {
916 if (!parse_object(old_sha1)) {
917 old_sha1 = NULL;
918 if (ref_exists(name)) {
919 rp_warning("Allowing deletion of corrupt ref.");
920 } else {
921 rp_warning("Deleting a non-existent ref.");
922 cmd->did_not_exist = 1;
923 }
924 }
925 if (delete_ref(namespaced_name, old_sha1, 0)) {
926 rp_error("failed to delete %s", name);
927 return "failed to delete";
928 }
929 return NULL; /* good */
930 }
931 else {
932 struct strbuf err = STRBUF_INIT;
933 struct ref_transaction *transaction;
934 if (shallow_update && si->shallow_ref[cmd->index] &&
936 update_shallow_ref(cmd, si))
937 return "shallow error";
938 transaction = ref_transaction_begin(&err);
940 if (!transaction ||
941 ref_transaction_update(transaction, namespaced_name,
942 new_sha1, old_sha1, 0, 1, "push",
943 &err) ||
944 ref_transaction_commit(transaction, &err)) {
945 ref_transaction_free(transaction);
946 rp_error("%s", err.buf);
948 strbuf_release(&err);
949 return "failed to update ref";
950 }
951 ref_transaction_free(transaction);
953 strbuf_release(&err);
954 return NULL; /* good */
955 }
956}
957static void run_update_post_hook(struct command *commands)
959{
960 struct command *cmd;
961 int argc;
962 const char **argv;
963 struct child_process proc = CHILD_PROCESS_INIT;
964 char *hook;
965 hook = find_hook("post-update");
967 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
968 if (cmd->error_string || cmd->did_not_exist)
969 continue;
970 argc++;
971 }
972 if (!argc || !hook)
973 return;
974 argv = xmalloc(sizeof(*argv) * (2 + argc));
976 argv[0] = hook;
977 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
979 if (cmd->error_string || cmd->did_not_exist)
980 continue;
981 argv[argc] = xstrdup(cmd->ref_name);
982 argc++;
983 }
984 argv[argc] = NULL;
985 proc.no_stdin = 1;
987 proc.stdout_to_stderr = 1;
988 proc.err = use_sideband ? -1 : 0;
989 proc.argv = argv;
990 if (!start_command(&proc)) {
992 if (use_sideband)
993 copy_to_sideband(proc.err, -1, NULL);
994 finish_command(&proc);
995 }
996}
997static void check_aliased_update(struct command *cmd, struct string_list *list)
999{
1000 struct strbuf buf = STRBUF_INIT;
1001 const char *dst_name;
1002 struct string_list_item *item;
1003 struct command *dst_cmd;
1004 unsigned char sha1[20];
1005 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
1006 int flag;
1007 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
1009 dst_name = resolve_ref_unsafe(buf.buf, 0, sha1, &flag);
1010 strbuf_release(&buf);
1011 if (!(flag & REF_ISSYMREF))
1013 return;
1014 dst_name = strip_namespace(dst_name);
1016 if (!dst_name) {
1017 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
1018 cmd->skip_update = 1;
1019 cmd->error_string = "broken symref";
1020 return;
1021 }
1022 if ((item = string_list_lookup(list, dst_name)) == NULL)
1024 return;
1025 cmd->skip_update = 1;
1027 dst_cmd = (struct command *) item->util;
1029 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
1031 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
1032 return;
1033 dst_cmd->skip_update = 1;
1035 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
1037 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
1038 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
1039 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
1040 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1041 " its target '%s' (%s..%s)",
1042 cmd->ref_name, cmd_oldh, cmd_newh,
1043 dst_cmd->ref_name, dst_oldh, dst_newh);
1044 cmd->error_string = dst_cmd->error_string =
1046 "inconsistent aliased update";
1047}
1048static void check_aliased_updates(struct command *commands)
1050{
1051 struct command *cmd;
1052 struct string_list ref_list = STRING_LIST_INIT_NODUP;
1053 for (cmd = commands; cmd; cmd = cmd->next) {
1055 struct string_list_item *item =
1056 string_list_append(&ref_list, cmd->ref_name);
1057 item->util = (void *)cmd;
1058 }
1059 sort_string_list(&ref_list);
1060 for (cmd = commands; cmd; cmd = cmd->next) {
1062 if (!cmd->error_string)
1063 check_aliased_update(cmd, &ref_list);
1064 }
1065 string_list_clear(&ref_list, 0);
1067}
1068static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
1070{
1071 struct command **cmd_list = cb_data;
1072 struct command *cmd = *cmd_list;
1073 if (!cmd || is_null_sha1(cmd->new_sha1))
1075 return -1; /* end of list */
1076 *cmd_list = NULL; /* this returns only one */
1077 hashcpy(sha1, cmd->new_sha1);
1078 return 0;
1079}
1080static void set_connectivity_errors(struct command *commands,
1082 struct shallow_info *si)
1083{
1084 struct command *cmd;
1085 for (cmd = commands; cmd; cmd = cmd->next) {
1087 struct command *singleton = cmd;
1088 if (shallow_update && si->shallow_ref[cmd->index])
1089 /* to be checked in update_shallow_ref() */
1090 continue;
1091 if (!check_everything_connected(command_singleton_iterator,
1092 0, &singleton))
1093 continue;
1094 cmd->error_string = "missing necessary objects";
1095 }
1096}
1097struct iterate_data {
1099 struct command *cmds;
1100 struct shallow_info *si;
1101};
1102static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
1104{
1105 struct iterate_data *data = cb_data;
1106 struct command **cmd_list = &data->cmds;
1107 struct command *cmd = *cmd_list;
1108 for (; cmd; cmd = cmd->next) {
1110 if (shallow_update && data->si->shallow_ref[cmd->index])
1111 /* to be checked in update_shallow_ref() */
1112 continue;
1113 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
1114 hashcpy(sha1, cmd->new_sha1);
1115 *cmd_list = cmd->next;
1116 return 0;
1117 }
1118 }
1119 *cmd_list = NULL;
1120 return -1; /* end of list */
1121}
1122static void reject_updates_to_hidden(struct command *commands)
1124{
1125 struct command *cmd;
1126 for (cmd = commands; cmd; cmd = cmd->next) {
1128 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
1129 continue;
1130 if (is_null_sha1(cmd->new_sha1))
1131 cmd->error_string = "deny deleting a hidden ref";
1132 else
1133 cmd->error_string = "deny updating a hidden ref";
1134 }
1135}
1136static void execute_commands(struct command *commands,
1138 const char *unpacker_error,
1139 struct shallow_info *si)
1140{
1141 int checked_connectivity;
1142 struct command *cmd;
1143 unsigned char sha1[20];
1144 struct iterate_data data;
1145 if (unpacker_error) {
1147 for (cmd = commands; cmd; cmd = cmd->next)
1148 cmd->error_string = "unpacker error";
1149 return;
1150 }
1151 data.cmds = commands;
1153 data.si = si;
1154 if (check_everything_connected(iterate_receive_command_list, 0, &data))
1155 set_connectivity_errors(commands, si);
1156 reject_updates_to_hidden(commands);
1158 if (run_receive_hook(commands, "pre-receive", 0)) {
1160 for (cmd = commands; cmd; cmd = cmd->next) {
1161 if (!cmd->error_string)
1162 cmd->error_string = "pre-receive hook declined";
1163 }
1164 return;
1165 }
1166 check_aliased_updates(commands);
1168 free(head_name_to_free);
1170 head_name = head_name_to_free = resolve_refdup("HEAD", 0, sha1, NULL);
1171 checked_connectivity = 1;
1173 for (cmd = commands; cmd; cmd = cmd->next) {
1174 if (cmd->error_string)
1175 continue;
1176 if (cmd->skip_update)
1178 continue;
1179 cmd->error_string = update(cmd, si);
1181 if (shallow_update && !cmd->error_string &&
1182 si->shallow_ref[cmd->index]) {
1183 error("BUG: connectivity check has not been run on ref %s",
1184 cmd->ref_name);
1185 checked_connectivity = 0;
1186 }
1187 }
1188 if (shallow_update && !checked_connectivity)
1190 error("BUG: run 'git fsck' for safety.\n"
1191 "If there are errors, try to remove "
1192 "the reported refs above");
1193}
1194static struct command **queue_command(struct command **tail,
1196 const char *line,
1197 int linelen)
1198{
1199 unsigned char old_sha1[20], new_sha1[20];
1200 struct command *cmd;
1201 const char *refname;
1202 int reflen;
1203 if (linelen < 83 ||
1205 line[40] != ' ' ||
1206 line[81] != ' ' ||
1207 get_sha1_hex(line, old_sha1) ||
1208 get_sha1_hex(line + 41, new_sha1))
1209 die("protocol error: expected old/new/ref, got '%s'", line);
1210 refname = line + 82;
1212 reflen = linelen - 82;
1213 cmd = xcalloc(1, sizeof(struct command) + reflen + 1);
1214 hashcpy(cmd->old_sha1, old_sha1);
1215 hashcpy(cmd->new_sha1, new_sha1);
1216 memcpy(cmd->ref_name, refname, reflen);
1217 cmd->ref_name[reflen] = '\0';
1218 *tail = cmd;
1219 return &cmd->next;
1220}
1221static void queue_commands_from_cert(struct command **tail,
1223 struct strbuf *push_cert)
1224{
1225 const char *boc, *eoc;
1226 if (*tail)
1228 die("protocol error: got both push certificate and unsigned commands");
1229 boc = strstr(push_cert->buf, "\n\n");
1231 if (!boc)
1232 die("malformed push certificate %.*s", 100, push_cert->buf);
1233 else
1234 boc += 2;
1235 eoc = push_cert->buf + parse_signature(push_cert->buf, push_cert->len);
1236 while (boc < eoc) {
1238 const char *eol = memchr(boc, '\n', eoc - boc);
1239 tail = queue_command(tail, boc, eol ? eol - boc : eoc - eol);
1240 boc = eol ? eol + 1 : eoc;
1241 }
1242}
1243static struct command *read_head_info(struct sha1_array *shallow)
1245{
1246 struct command *commands = NULL;
1247 struct command **p = &commands;
1248 for (;;) {
1249 char *line;
1250 int len, linelen;
1251 line = packet_read_line(0, &len);
1253 if (!line)
1254 break;
1255 if (len == 48 && starts_with(line, "shallow ")) {
1257 unsigned char sha1[20];
1258 if (get_sha1_hex(line + 8, sha1))
1259 die("protocol error: expected shallow sha, got '%s'",
1260 line + 8);
1261 sha1_array_append(shallow, sha1);
1262 continue;
1263 }
1264 linelen = strlen(line);
1266 if (linelen < len) {
1267 const char *feature_list = line + linelen + 1;
1268 if (parse_feature_request(feature_list, "report-status"))
1269 report_status = 1;
1270 if (parse_feature_request(feature_list, "side-band-64k"))
1271 use_sideband = LARGE_PACKET_MAX;
1272 if (parse_feature_request(feature_list, "quiet"))
1273 quiet = 1;
1274 }
1275 if (!strcmp(line, "push-cert")) {
1277 int true_flush = 0;
1278 char certbuf[1024];
1279 for (;;) {
1281 len = packet_read(0, NULL, NULL,
1282 certbuf, sizeof(certbuf), 0);
1283 if (!len) {
1284 true_flush = 1;
1285 break;
1286 }
1287 if (!strcmp(certbuf, "push-cert-end\n"))
1288 break; /* end of cert */
1289 strbuf_addstr(&push_cert, certbuf);
1290 }
1291 if (true_flush)
1293 break;
1294 continue;
1295 }
1296 p = queue_command(p, line, linelen);
1298 }
1299 if (push_cert.len)
1301 queue_commands_from_cert(p, &push_cert);
1302 return commands;
1304}
1305static const char *parse_pack_header(struct pack_header *hdr)
1307{
1308 switch (read_pack_header(0, hdr)) {
1309 case PH_ERROR_EOF:
1310 return "eof before pack header was fully read";
1311 case PH_ERROR_PACK_SIGNATURE:
1313 return "protocol error (pack signature mismatch detected)";
1314 case PH_ERROR_PROTOCOL:
1316 return "protocol error (pack version unsupported)";
1317 default:
1319 return "unknown error in parse_pack_header";
1320 case 0:
1322 return NULL;
1323 }
1324}
1325static const char *pack_lockfile;
1327static const char *unpack(int err_fd, struct shallow_info *si)
1329{
1330 struct pack_header hdr;
1331 const char *hdr_err;
1332 int status;
1333 char hdr_arg[38];
1334 struct child_process child = CHILD_PROCESS_INIT;
1335 int fsck_objects = (receive_fsck_objects >= 0
1336 ? receive_fsck_objects
1337 : transfer_fsck_objects >= 0
1338 ? transfer_fsck_objects
1339 : 0);
1340 hdr_err = parse_pack_header(&hdr);
1342 if (hdr_err) {
1343 if (err_fd > 0)
1344 close(err_fd);
1345 return hdr_err;
1346 }
1347 snprintf(hdr_arg, sizeof(hdr_arg),
1348 "--pack_header=%"PRIu32",%"PRIu32,
1349 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
1350 if (si->nr_ours || si->nr_theirs) {
1352 alt_shallow_file = setup_temporary_shallow(si->shallow);
1353 argv_array_push(&child.args, "--shallow-file");
1354 argv_array_push(&child.args, alt_shallow_file);
1355 }
1356 if (ntohl(hdr.hdr_entries) < unpack_limit) {
1358 argv_array_pushl(&child.args, "unpack-objects", hdr_arg, NULL);
1359 if (quiet)
1360 argv_array_push(&child.args, "-q");
1361 if (fsck_objects)
1362 argv_array_push(&child.args, "--strict");
1363 child.no_stdout = 1;
1364 child.err = err_fd;
1365 child.git_cmd = 1;
1366 status = run_command(&child);
1367 if (status)
1368 return "unpack-objects abnormal exit";
1369 } else {
1370 int s;
1371 char keep_arg[256];
1372 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
1374 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
1375 strcpy(keep_arg + s, "localhost");
1376 argv_array_pushl(&child.args, "index-pack",
1378 "--stdin", hdr_arg, keep_arg, NULL);
1379 if (fsck_objects)
1380 argv_array_push(&child.args, "--strict");
1381 if (fix_thin)
1382 argv_array_push(&child.args, "--fix-thin");
1383 child.out = -1;
1384 child.err = err_fd;
1385 child.git_cmd = 1;
1386 status = start_command(&child);
1387 if (status)
1388 return "index-pack fork failed";
1389 pack_lockfile = index_pack_lockfile(child.out);
1390 close(child.out);
1391 status = finish_command(&child);
1392 if (status)
1393 return "index-pack abnormal exit";
1394 reprepare_packed_git();
1395 }
1396 return NULL;
1397}
1398static const char *unpack_with_sideband(struct shallow_info *si)
1400{
1401 struct async muxer;
1402 const char *ret;
1403 if (!use_sideband)
1405 return unpack(0, si);
1406 memset(&muxer, 0, sizeof(muxer));
1408 muxer.proc = copy_to_sideband;
1409 muxer.in = -1;
1410 if (start_async(&muxer))
1411 return NULL;
1412 ret = unpack(muxer.in, si);
1414 finish_async(&muxer);
1416 return ret;
1417}
1418static void prepare_shallow_update(struct command *commands,
1420 struct shallow_info *si)
1421{
1422 int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1423 si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1425 si->shallow->nr);
1426 assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1427 si->need_reachability_test =
1429 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1430 si->reachable =
1431 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1432 si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1433 for (i = 0; i < si->nr_ours; i++)
1435 si->need_reachability_test[si->ours[i]] = 1;
1436 for (i = 0; i < si->shallow->nr; i++) {
1438 if (!si->used_shallow[i])
1439 continue;
1440 for (j = 0; j < bitmap_size; j++) {
1441 if (!si->used_shallow[i][j])
1442 continue;
1443 si->need_reachability_test[i]++;
1444 for (k = 0; k < 32; k++)
1445 if (si->used_shallow[i][j] & (1 << k))
1446 si->shallow_ref[j * 32 + k]++;
1447 }
1448 /*
1450 * true for those associated with some refs and belong
1451 * in "ours" list aka "step 7 not done yet"
1452 */
1453 si->need_reachability_test[i] =
1454 si->need_reachability_test[i] > 1;
1455 }
1456 /*
1458 * keep hooks happy by forcing a temporary shallow file via
1459 * env variable because we can't add --shallow-file to every
1460 * command. check_everything_connected() will be done with
1461 * true .git/shallow though.
1462 */
1463 setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1464}
1465static void update_shallow_info(struct command *commands,
1467 struct shallow_info *si,
1468 struct sha1_array *ref)
1469{
1470 struct command *cmd;
1471 int *ref_status;
1472 remove_nonexistent_theirs_shallow(si);
1473 if (!si->nr_ours && !si->nr_theirs) {
1474 shallow_update = 0;
1475 return;
1476 }
1477 for (cmd = commands; cmd; cmd = cmd->next) {
1479 if (is_null_sha1(cmd->new_sha1))
1480 continue;
1481 sha1_array_append(ref, cmd->new_sha1);
1482 cmd->index = ref->nr - 1;
1483 }
1484 si->ref = ref;
1485 if (shallow_update) {
1487 prepare_shallow_update(commands, si);
1488 return;
1489 }
1490 ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1492 assign_shallow_commits_to_refs(si, NULL, ref_status);
1493 for (cmd = commands; cmd; cmd = cmd->next) {
1494 if (is_null_sha1(cmd->new_sha1))
1495 continue;
1496 if (ref_status[cmd->index]) {
1497 cmd->error_string = "shallow update not allowed";
1498 cmd->skip_update = 1;
1499 }
1500 }
1501 free(ref_status);
1502}
1503static void report(struct command *commands, const char *unpack_status)
1505{
1506 struct command *cmd;
1507 struct strbuf buf = STRBUF_INIT;
1508 packet_buf_write(&buf, "unpack %s\n",
1510 unpack_status ? unpack_status : "ok");
1511 for (cmd = commands; cmd; cmd = cmd->next) {
1512 if (!cmd->error_string)
1513 packet_buf_write(&buf, "ok %s\n",
1514 cmd->ref_name);
1515 else
1516 packet_buf_write(&buf, "ng %s %s\n",
1517 cmd->ref_name, cmd->error_string);
1518 }
1519 packet_buf_flush(&buf);
1520 if (use_sideband)
1522 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1523 else
1524 write_or_die(1, buf.buf, buf.len);
1525 strbuf_release(&buf);
1526}
1527static int delete_only(struct command *commands)
1529{
1530 struct command *cmd;
1531 for (cmd = commands; cmd; cmd = cmd->next) {
1532 if (!is_null_sha1(cmd->new_sha1))
1533 return 0;
1534 }
1535 return 1;
1536}
1537int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1539{
1540 int advertise_refs = 0;
1541 int i;
1542 struct command *commands;
1543 struct sha1_array shallow = SHA1_ARRAY_INIT;
1544 struct sha1_array ref = SHA1_ARRAY_INIT;
1545 struct shallow_info si;
1546 packet_trace_identity("receive-pack");
1548 argv++;
1550 for (i = 1; i < argc; i++) {
1551 const char *arg = *argv++;
1552 if (*arg == '-') {
1554 if (!strcmp(arg, "--quiet")) {
1555 quiet = 1;
1556 continue;
1557 }
1558 if (!strcmp(arg, "--advertise-refs")) {
1560 advertise_refs = 1;
1561 continue;
1562 }
1563 if (!strcmp(arg, "--stateless-rpc")) {
1564 stateless_rpc = 1;
1565 continue;
1566 }
1567 if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1568 fix_thin = 0;
1569 continue;
1570 }
1571 usage(receive_pack_usage);
1573 }
1574 if (service_dir)
1575 usage(receive_pack_usage);
1576 service_dir = arg;
1577 }
1578 if (!service_dir)
1579 usage(receive_pack_usage);
1580 setup_path();
1582 if (!enter_repo(service_dir, 0))
1584 die("'%s' does not appear to be a git repository", service_dir);
1585 git_config(receive_pack_config, NULL);
1587 if (cert_nonce_seed)
1588 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
1589 if (0 <= transfer_unpack_limit)
1591 unpack_limit = transfer_unpack_limit;
1592 else if (0 <= receive_unpack_limit)
1593 unpack_limit = receive_unpack_limit;
1594 if (advertise_refs || !stateless_rpc) {
1596 write_head_info();
1597 }
1598 if (advertise_refs)
1599 return 0;
1600 if ((commands = read_head_info(&shallow)) != NULL) {
1602 const char *unpack_status = NULL;
1603 prepare_shallow_info(&si, &shallow);
1605 if (!si.nr_ours && !si.nr_theirs)
1606 shallow_update = 0;
1607 if (!delete_only(commands)) {
1608 unpack_status = unpack_with_sideband(&si);
1609 update_shallow_info(commands, &si, &ref);
1610 }
1611 execute_commands(commands, unpack_status, &si);
1612 if (pack_lockfile)
1613 unlink_or_warn(pack_lockfile);
1614 if (report_status)
1615 report(commands, unpack_status);
1616 run_receive_hook(commands, "post-receive", 1);
1617 run_update_post_hook(commands);
1618 if (auto_gc) {
1619 const char *argv_gc_auto[] = {
1620 "gc", "--auto", "--quiet", NULL,
1621 };
1622 int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1623 run_command_v_opt(argv_gc_auto, opt);
1624 }
1625 if (auto_update_server_info)
1626 update_server_info(0);
1627 clear_shallow_info(&si);
1628 }
1629 if (use_sideband)
1630 packet_flush(1);
1631 sha1_array_clear(&shallow);
1632 sha1_array_clear(&ref);
1633 free((void *)push_cert_nonce);
1634 return 0;
1635}