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};
31static int deny_deletes;
33static int deny_non_fast_forwards;
34static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
35static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
36static int receive_fsck_objects = -1;
37static int transfer_fsck_objects = -1;
38static int receive_unpack_limit = -1;
39static int transfer_unpack_limit = -1;
40static int unpack_limit = 100;
41static int report_status;
42static int use_sideband;
43static int quiet;
44static int prefer_ofs_delta = 1;
45static int auto_update_server_info;
46static int auto_gc = 1;
47static int fix_thin = 1;
48static int stateless_rpc;
49static const char *service_dir;
50static const char *head_name;
51static void *head_name_to_free;
52static int sent_capabilities;
53static int shallow_update;
54static const char *alt_shallow_file;
55static struct strbuf push_cert = STRBUF_INIT;
56static unsigned char push_cert_sha1[20];
57static struct signature_check sigcheck;
58static const char *push_cert_nonce;
59static const char *cert_nonce_seed;
60static const char *NONCE_UNSOLICITED = "UNSOLICITED";
62static const char *NONCE_BAD = "BAD";
63static const char *NONCE_MISSING = "MISSING";
64static const char *NONCE_OK = "OK";
65static const char *NONCE_SLOP = "SLOP";
66static const char *nonce_status;
67static long nonce_stamp_slop;
68static unsigned long nonce_stamp_slop_limit;
69static enum deny_action parse_deny_action(const char *var, const char *value)
71{
72 if (value) {
73 if (!strcasecmp(value, "ignore"))
74 return DENY_IGNORE;
75 if (!strcasecmp(value, "warn"))
76 return DENY_WARN;
77 if (!strcasecmp(value, "refuse"))
78 return DENY_REFUSE;
79 }
80 if (git_config_bool(var, value))
81 return DENY_REFUSE;
82 return DENY_IGNORE;
83}
84static int receive_pack_config(const char *var, const char *value, void *cb)
86{
87 int status = parse_hide_refs_config(var, value, "receive");
88 if (status)
90 return status;
91 if (strcmp(var, "receive.denydeletes") == 0) {
93 deny_deletes = git_config_bool(var, value);
94 return 0;
95 }
96 if (strcmp(var, "receive.denynonfastforwards") == 0) {
98 deny_non_fast_forwards = git_config_bool(var, value);
99 return 0;
100 }
101 if (strcmp(var, "receive.unpacklimit") == 0) {
103 receive_unpack_limit = git_config_int(var, value);
104 return 0;
105 }
106 if (strcmp(var, "transfer.unpacklimit") == 0) {
108 transfer_unpack_limit = git_config_int(var, value);
109 return 0;
110 }
111 if (strcmp(var, "receive.fsckobjects") == 0) {
113 receive_fsck_objects = git_config_bool(var, value);
114 return 0;
115 }
116 if (strcmp(var, "transfer.fsckobjects") == 0) {
118 transfer_fsck_objects = git_config_bool(var, value);
119 return 0;
120 }
121 if (!strcmp(var, "receive.denycurrentbranch")) {
123 deny_current_branch = parse_deny_action(var, value);
124 return 0;
125 }
126 if (strcmp(var, "receive.denydeletecurrent") == 0) {
128 deny_delete_current = parse_deny_action(var, value);
129 return 0;
130 }
131 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
133 prefer_ofs_delta = git_config_bool(var, value);
134 return 0;
135 }
136 if (strcmp(var, "receive.updateserverinfo") == 0) {
138 auto_update_server_info = git_config_bool(var, value);
139 return 0;
140 }
141 if (strcmp(var, "receive.autogc") == 0) {
143 auto_gc = git_config_bool(var, value);
144 return 0;
145 }
146 if (strcmp(var, "receive.shallowupdate") == 0) {
148 shallow_update = git_config_bool(var, value);
149 return 0;
150 }
151 if (strcmp(var, "receive.certnonceseed") == 0)
153 return git_config_string(&cert_nonce_seed, var, value);
154 if (strcmp(var, "receive.certnonceslop") == 0) {
156 nonce_stamp_slop_limit = git_config_ulong(var, value);
157 return 0;
158 }
159 return git_default_config(var, value, cb);
161}
162static void show_ref(const char *path, const unsigned char *sha1)
164{
165 if (ref_is_hidden(path))
166 return;
167 if (sent_capabilities) {
169 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
170 } else {
171 struct strbuf cap = STRBUF_INIT;
172 strbuf_addstr(&cap,
174 "report-status delete-refs side-band-64k quiet");
175 if (prefer_ofs_delta)
176 strbuf_addstr(&cap, " ofs-delta");
177 if (push_cert_nonce)
178 strbuf_addf(&cap, " push-cert=%s", push_cert_nonce);
179 strbuf_addf(&cap, " agent=%s", git_user_agent_sanitized());
180 packet_write(1, "%s %s%c%s\n",
181 sha1_to_hex(sha1), path, 0, cap.buf);
182 strbuf_release(&cap);
183 sent_capabilities = 1;
184 }
185}
186static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
188{
189 path = strip_namespace(path);
190 /*
191 * Advertise refs outside our current namespace as ".have"
192 * refs, so that the client can use them to minimize data
193 * transfer but will otherwise ignore them. This happens to
194 * cover ".have" that are thrown in by add_one_alternate_ref()
195 * to mark histories that are complete in our alternates as
196 * well.
197 */
198 if (!path)
199 path = ".have";
200 show_ref(path, sha1);
201 return 0;
202}
203static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
205{
206 show_ref(".have", sha1);
207}
208static void collect_one_alternate_ref(const struct ref *ref, void *data)
210{
211 struct sha1_array *sa = data;
212 sha1_array_append(sa, ref->old_sha1);
213}
214static void write_head_info(void)
216{
217 struct sha1_array sa = SHA1_ARRAY_INIT;
218 for_each_alternate_ref(collect_one_alternate_ref, &sa);
219 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
220 sha1_array_clear(&sa);
221 for_each_ref(show_ref_cb, NULL);
222 if (!sent_capabilities)
223 show_ref("capabilities^{}", null_sha1);
224 advertise_shallow_grafts(1);
226 /* EOF */
228 packet_flush(1);
229}
230struct command {
232 struct command *next;
233 const char *error_string;
234 unsigned int skip_update:1,
235 did_not_exist:1;
236 int index;
237 unsigned char old_sha1[20];
238 unsigned char new_sha1[20];
239 char ref_name[FLEX_ARRAY]; /* more */
240};
241static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
243static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
244static void report_message(const char *prefix, const char *err, va_list params)
246{
247 int sz = strlen(prefix);
248 char msg[4096];
249 strncpy(msg, prefix, sz);
251 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
252 if (sz > (sizeof(msg) - 1))
253 sz = sizeof(msg) - 1;
254 msg[sz++] = '\n';
255 if (use_sideband)
257 send_sideband(1, 2, msg, sz, use_sideband);
258 else
259 xwrite(2, msg, sz);
260}
261static void rp_warning(const char *err, ...)
263{
264 va_list params;
265 va_start(params, err);
266 report_message("warning: ", err, params);
267 va_end(params);
268}
269static void rp_error(const char *err, ...)
271{
272 va_list params;
273 va_start(params, err);
274 report_message("error: ", err, params);
275 va_end(params);
276}
277static int copy_to_sideband(int in, int out, void *arg)
279{
280 char data[128];
281 while (1) {
282 ssize_t sz = xread(in, data, sizeof(data));
283 if (sz <= 0)
284 break;
285 send_sideband(1, 2, data, sz, use_sideband);
286 }
287 close(in);
288 return 0;
289}
290#define HMAC_BLOCK_SIZE 64
292static void hmac_sha1(unsigned char *out,
294 const char *key_in, size_t key_len,
295 const char *text, size_t text_len)
296{
297 unsigned char key[HMAC_BLOCK_SIZE];
298 unsigned char k_ipad[HMAC_BLOCK_SIZE];
299 unsigned char k_opad[HMAC_BLOCK_SIZE];
300 int i;
301 git_SHA_CTX ctx;
302 /* RFC 2104 2. (1) */
304 memset(key, '\0', HMAC_BLOCK_SIZE);
305 if (HMAC_BLOCK_SIZE < key_len) {
306 git_SHA1_Init(&ctx);
307 git_SHA1_Update(&ctx, key_in, key_len);
308 git_SHA1_Final(key, &ctx);
309 } else {
310 memcpy(key, key_in, key_len);
311 }
312 /* RFC 2104 2. (2) & (5) */
314 for (i = 0; i < sizeof(key); i++) {
315 k_ipad[i] = key[i] ^ 0x36;
316 k_opad[i] = key[i] ^ 0x5c;
317 }
318 /* RFC 2104 2. (3) & (4) */
320 git_SHA1_Init(&ctx);
321 git_SHA1_Update(&ctx, k_ipad, sizeof(k_ipad));
322 git_SHA1_Update(&ctx, text, text_len);
323 git_SHA1_Final(out, &ctx);
324 /* RFC 2104 2. (6) & (7) */
326 git_SHA1_Init(&ctx);
327 git_SHA1_Update(&ctx, k_opad, sizeof(k_opad));
328 git_SHA1_Update(&ctx, out, 20);
329 git_SHA1_Final(out, &ctx);
330}
331static char *prepare_push_cert_nonce(const char *path, unsigned long stamp)
333{
334 struct strbuf buf = STRBUF_INIT;
335 unsigned char sha1[20];
336 strbuf_addf(&buf, "%s:%lu", path, stamp);
338 hmac_sha1(sha1, buf.buf, buf.len, cert_nonce_seed, strlen(cert_nonce_seed));;
339 strbuf_release(&buf);
340 /* RFC 2104 5. HMAC-SHA1-80 */
342 strbuf_addf(&buf, "%lu-%.*s", stamp, 20, sha1_to_hex(sha1));
343 return strbuf_detach(&buf, NULL);
344}
345/*
347 * NEEDSWORK: reuse find_commit_header() from jk/commit-author-parsing
348 * after dropping "_commit" from its name and possibly moving it out
349 * of commit.c
350 */
351static char *find_header(const char *msg, size_t len, const char *key)
352{
353 int key_len = strlen(key);
354 const char *line = msg;
355 while (line && line < msg + len) {
357 const char *eol = strchrnul(line, '\n');
358 if ((msg + len <= eol) || line == eol)
360 return NULL;
361 if (line + key_len < eol &&
362 !memcmp(line, key, key_len) && line[key_len] == ' ') {
363 int offset = key_len + 1;
364 return xmemdupz(line + offset, (eol - line) - offset);
365 }
366 line = *eol ? eol + 1 : NULL;
367 }
368 return NULL;
369}
370static const char *check_nonce(const char *buf, size_t len)
372{
373 char *nonce = find_header(buf, len, "nonce");
374 unsigned long stamp, ostamp;
375 char *bohmac, *expect = NULL;
376 const char *retval = NONCE_BAD;
377 if (!nonce) {
379 retval = NONCE_MISSING;
380 goto leave;
381 } else if (!push_cert_nonce) {
382 retval = NONCE_UNSOLICITED;
383 goto leave;
384 } else if (!strcmp(push_cert_nonce, nonce)) {
385 retval = NONCE_OK;
386 goto leave;
387 }
388 if (!stateless_rpc) {
390 /* returned nonce MUST match what we gave out earlier */
391 retval = NONCE_BAD;
392 goto leave;
393 }
394 /*
396 * In stateless mode, we may be receiving a nonce issued by
397 * another instance of the server that serving the same
398 * repository, and the timestamps may not match, but the
399 * nonce-seed and dir should match, so we can recompute and
400 * report the time slop.
401 *
402 * In addition, when a nonce issued by another instance has
403 * timestamp within receive.certnonceslop seconds, we pretend
404 * as if we issued that nonce when reporting to the hook.
405 */
406 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
408 if (*nonce <= '0' || '9' < *nonce) {
409 retval = NONCE_BAD;
410 goto leave;
411 }
412 stamp = strtoul(nonce, &bohmac, 10);
413 if (bohmac == nonce || bohmac[0] != '-') {
414 retval = NONCE_BAD;
415 goto leave;
416 }
417 expect = prepare_push_cert_nonce(service_dir, stamp);
419 if (strcmp(expect, nonce)) {
420 /* Not what we would have signed earlier */
421 retval = NONCE_BAD;
422 goto leave;
423 }
424 /*
426 * By how many seconds is this nonce stale? Negative value
427 * would mean it was issued by another server with its clock
428 * skewed in the future.
429 */
430 ostamp = strtoul(push_cert_nonce, NULL, 10);
431 nonce_stamp_slop = (long)ostamp - (long)stamp;
432 if (nonce_stamp_slop_limit &&
434 abs(nonce_stamp_slop) <= nonce_stamp_slop_limit) {
435 /*
436 * Pretend as if the received nonce (which passes the
437 * HMAC check, so it is not a forged by third-party)
438 * is what we issued.
439 */
440 free((void *)push_cert_nonce);
441 push_cert_nonce = xstrdup(nonce);
442 retval = NONCE_OK;
443 } else {
444 retval = NONCE_SLOP;
445 }
446leave:
448 free(nonce);
449 free(expect);
450 return retval;
451}
452static void prepare_push_cert_sha1(struct child_process *proc)
454{
455 static int already_done;
456 if (!push_cert.len)
458 return;
459 if (!already_done) {
461 struct strbuf gpg_output = STRBUF_INIT;
462 struct strbuf gpg_status = STRBUF_INIT;
463 int bogs /* beginning_of_gpg_sig */;
464 already_done = 1;
466 if (write_sha1_file(push_cert.buf, push_cert.len, "blob", push_cert_sha1))
467 hashclr(push_cert_sha1);
468 memset(&sigcheck, '\0', sizeof(sigcheck));
470 sigcheck.result = 'N';
471 bogs = parse_signature(push_cert.buf, push_cert.len);
473 if (verify_signed_buffer(push_cert.buf, bogs,
474 push_cert.buf + bogs, push_cert.len - bogs,
475 &gpg_output, &gpg_status) < 0) {
476 ; /* error running gpg */
477 } else {
478 sigcheck.payload = push_cert.buf;
479 sigcheck.gpg_output = gpg_output.buf;
480 sigcheck.gpg_status = gpg_status.buf;
481 parse_gpg_output(&sigcheck);
482 }
483 strbuf_release(&gpg_output);
485 strbuf_release(&gpg_status);
486 nonce_status = check_nonce(push_cert.buf, bogs);
487 }
488 if (!is_null_sha1(push_cert_sha1)) {
489 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT=%s",
490 sha1_to_hex(push_cert_sha1));
491 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_SIGNER=%s",
492 sigcheck.signer ? sigcheck.signer : "");
493 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_KEY=%s",
494 sigcheck.key ? sigcheck.key : "");
495 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_STATUS=%c",
496 sigcheck.result);
497 if (push_cert_nonce) {
498 argv_array_pushf(&proc->env_array,
499 "GIT_PUSH_CERT_NONCE=%s",
500 push_cert_nonce);
501 argv_array_pushf(&proc->env_array,
502 "GIT_PUSH_CERT_NONCE_STATUS=%s",
503 nonce_status);
504 if (nonce_status == NONCE_SLOP)
505 argv_array_pushf(&proc->env_array,
506 "GIT_PUSH_CERT_NONCE_SLOP=%ld",
507 nonce_stamp_slop);
508 }
509 }
510}
511typedef int (*feed_fn)(void *, const char **, size_t *);
513static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
514{
515 struct child_process proc = CHILD_PROCESS_INIT;
516 struct async muxer;
517 const char *argv[2];
518 int code;
519 argv[0] = find_hook(hook_name);
521 if (!argv[0])
522 return 0;
523 argv[1] = NULL;
525 proc.argv = argv;
527 proc.in = -1;
528 proc.stdout_to_stderr = 1;
529 if (use_sideband) {
531 memset(&muxer, 0, sizeof(muxer));
532 muxer.proc = copy_to_sideband;
533 muxer.in = -1;
534 code = start_async(&muxer);
535 if (code)
536 return code;
537 proc.err = muxer.in;
538 }
539 prepare_push_cert_sha1(&proc);
541 code = start_command(&proc);
543 if (code) {
544 if (use_sideband)
545 finish_async(&muxer);
546 return code;
547 }
548 sigchain_push(SIGPIPE, SIG_IGN);
550 while (1) {
552 const char *buf;
553 size_t n;
554 if (feed(feed_state, &buf, &n))
555 break;
556 if (write_in_full(proc.in, buf, n) != n)
557 break;
558 }
559 close(proc.in);
560 if (use_sideband)
561 finish_async(&muxer);
562 sigchain_pop(SIGPIPE);
564 return finish_command(&proc);
566}
567struct receive_hook_feed_state {
569 struct command *cmd;
570 int skip_broken;
571 struct strbuf buf;
572};
573static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
575{
576 struct receive_hook_feed_state *state = state_;
577 struct command *cmd = state->cmd;
578 while (cmd &&
580 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
581 cmd = cmd->next;
582 if (!cmd)
583 return -1; /* EOF */
584 strbuf_reset(&state->buf);
585 strbuf_addf(&state->buf, "%s %s %s\n",
586 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
587 cmd->ref_name);
588 state->cmd = cmd->next;
589 if (bufp) {
590 *bufp = state->buf.buf;
591 *sizep = state->buf.len;
592 }
593 return 0;
594}
595static int run_receive_hook(struct command *commands, const char *hook_name,
597 int skip_broken)
598{
599 struct receive_hook_feed_state state;
600 int status;
601 strbuf_init(&state.buf, 0);
603 state.cmd = commands;
604 state.skip_broken = skip_broken;
605 if (feed_receive_hook(&state, NULL, NULL))
606 return 0;
607 state.cmd = commands;
608 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
609 strbuf_release(&state.buf);
610 return status;
611}
612static int run_update_hook(struct command *cmd)
614{
615 const char *argv[5];
616 struct child_process proc = CHILD_PROCESS_INIT;
617 int code;
618 argv[0] = find_hook("update");
620 if (!argv[0])
621 return 0;
622 argv[1] = cmd->ref_name;
624 argv[2] = sha1_to_hex(cmd->old_sha1);
625 argv[3] = sha1_to_hex(cmd->new_sha1);
626 argv[4] = NULL;
627 proc.no_stdin = 1;
629 proc.stdout_to_stderr = 1;
630 proc.err = use_sideband ? -1 : 0;
631 proc.argv = argv;
632 code = start_command(&proc);
634 if (code)
635 return code;
636 if (use_sideband)
637 copy_to_sideband(proc.err, -1, NULL);
638 return finish_command(&proc);
639}
640static int is_ref_checked_out(const char *ref)
642{
643 if (is_bare_repository())
644 return 0;
645 if (!head_name)
647 return 0;
648 return !strcmp(head_name, ref);
649}
650static char *refuse_unconfigured_deny_msg[] = {
652 "By default, updating the current branch in a non-bare repository",
653 "is denied, because it will make the index and work tree inconsistent",
654 "with what you pushed, and will require 'git reset --hard' to match",
655 "the work tree to HEAD.",
656 "",
657 "You can set 'receive.denyCurrentBranch' configuration variable to",
658 "'ignore' or 'warn' in the remote repository to allow pushing into",
659 "its current branch; however, this is not recommended unless you",
660 "arranged to update its work tree to match what you pushed in some",
661 "other way.",
662 "",
663 "To squelch this message and still keep the default behaviour, set",
664 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
665};
666static void refuse_unconfigured_deny(void)
668{
669 int i;
670 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
671 rp_error("%s", refuse_unconfigured_deny_msg[i]);
672}
673static char *refuse_unconfigured_deny_delete_current_msg[] = {
675 "By default, deleting the current branch is denied, because the next",
676 "'git clone' won't result in any file checked out, causing confusion.",
677 "",
678 "You can set 'receive.denyDeleteCurrent' configuration variable to",
679 "'warn' or 'ignore' in the remote repository to allow deleting the",
680 "current branch, with or without a warning message.",
681 "",
682 "To squelch this message, you can set it to 'refuse'."
683};
684static void refuse_unconfigured_deny_delete_current(void)
686{
687 int i;
688 for (i = 0;
689 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
690 i++)
691 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
692}
693static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
695static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
696{
697 static struct lock_file shallow_lock;
698 struct sha1_array extra = SHA1_ARRAY_INIT;
699 const char *alt_file;
700 uint32_t mask = 1 << (cmd->index % 32);
701 int i;
702 trace_printf_key(&trace_shallow,
704 "shallow: update_shallow_ref %s\n", cmd->ref_name);
705 for (i = 0; i < si->shallow->nr; i++)
706 if (si->used_shallow[i] &&
707 (si->used_shallow[i][cmd->index / 32] & mask) &&
708 !delayed_reachability_test(si, i))
709 sha1_array_append(&extra, si->shallow->sha1[i]);
710 setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
712 if (check_shallow_connected(command_singleton_iterator,
713 0, cmd, alt_file)) {
714 rollback_lock_file(&shallow_lock);
715 sha1_array_clear(&extra);
716 return -1;
717 }
718 commit_lock_file(&shallow_lock);
720 /*
722 * Make sure setup_alternate_shallow() for the next ref does
723 * not lose these new roots..
724 */
725 for (i = 0; i < extra.nr; i++)
726 register_shallow(extra.sha1[i]);
727 si->shallow_ref[cmd->index] = 0;
729 sha1_array_clear(&extra);
730 return 0;
731}
732static const char *update(struct command *cmd, struct shallow_info *si)
734{
735 const char *name = cmd->ref_name;
736 struct strbuf namespaced_name_buf = STRBUF_INIT;
737 const char *namespaced_name;
738 unsigned char *old_sha1 = cmd->old_sha1;
739 unsigned char *new_sha1 = cmd->new_sha1;
740 /* only refs/... are allowed */
742 if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
743 rp_error("refusing to create funny ref '%s' remotely", name);
744 return "funny refname";
745 }
746 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
748 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
749 if (is_ref_checked_out(namespaced_name)) {
751 switch (deny_current_branch) {
752 case DENY_IGNORE:
753 break;
754 case DENY_WARN:
755 rp_warning("updating the current branch");
756 break;
757 case DENY_REFUSE:
758 case DENY_UNCONFIGURED:
759 rp_error("refusing to update checked out branch: %s", name);
760 if (deny_current_branch == DENY_UNCONFIGURED)
761 refuse_unconfigured_deny();
762 return "branch is currently checked out";
763 }
764 }
765 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
767 error("unpack should have generated %s, "
768 "but I can't find it!", sha1_to_hex(new_sha1));
769 return "bad pack";
770 }
771 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
773 if (deny_deletes && starts_with(name, "refs/heads/")) {
774 rp_error("denying ref deletion for %s", name);
775 return "deletion prohibited";
776 }
777 if (!strcmp(namespaced_name, head_name)) {
779 switch (deny_delete_current) {
780 case DENY_IGNORE:
781 break;
782 case DENY_WARN:
783 rp_warning("deleting the current branch");
784 break;
785 case DENY_REFUSE:
786 case DENY_UNCONFIGURED:
787 if (deny_delete_current == DENY_UNCONFIGURED)
788 refuse_unconfigured_deny_delete_current();
789 rp_error("refusing to delete the current branch: %s", name);
790 return "deletion of the current branch prohibited";
791 }
792 }
793 }
794 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
796 !is_null_sha1(old_sha1) &&
797 starts_with(name, "refs/heads/")) {
798 struct object *old_object, *new_object;
799 struct commit *old_commit, *new_commit;
800 old_object = parse_object(old_sha1);
802 new_object = parse_object(new_sha1);
803 if (!old_object || !new_object ||
805 old_object->type != OBJ_COMMIT ||
806 new_object->type != OBJ_COMMIT) {
807 error("bad sha1 objects for %s", name);
808 return "bad ref";
809 }
810 old_commit = (struct commit *)old_object;
811 new_commit = (struct commit *)new_object;
812 if (!in_merge_bases(old_commit, new_commit)) {
813 rp_error("denying non-fast-forward %s"
814 " (you should pull first)", name);
815 return "non-fast-forward";
816 }
817 }
818 if (run_update_hook(cmd)) {
819 rp_error("hook declined to update %s", name);
820 return "hook declined";
821 }
822 if (is_null_sha1(new_sha1)) {
824 if (!parse_object(old_sha1)) {
825 old_sha1 = NULL;
826 if (ref_exists(name)) {
827 rp_warning("Allowing deletion of corrupt ref.");
828 } else {
829 rp_warning("Deleting a non-existent ref.");
830 cmd->did_not_exist = 1;
831 }
832 }
833 if (delete_ref(namespaced_name, old_sha1, 0)) {
834 rp_error("failed to delete %s", name);
835 return "failed to delete";
836 }
837 return NULL; /* good */
838 }
839 else {
840 struct strbuf err = STRBUF_INIT;
841 struct ref_transaction *transaction;
842 if (shallow_update && si->shallow_ref[cmd->index] &&
844 update_shallow_ref(cmd, si))
845 return "shallow error";
846 transaction = ref_transaction_begin(&err);
848 if (!transaction ||
849 ref_transaction_update(transaction, namespaced_name,
850 new_sha1, old_sha1, 0, 1, "push",
851 &err) ||
852 ref_transaction_commit(transaction, &err)) {
853 ref_transaction_free(transaction);
854 rp_error("%s", err.buf);
856 strbuf_release(&err);
857 return "failed to update ref";
858 }
859 ref_transaction_free(transaction);
861 strbuf_release(&err);
862 return NULL; /* good */
863 }
864}
865static void run_update_post_hook(struct command *commands)
867{
868 struct command *cmd;
869 int argc;
870 const char **argv;
871 struct child_process proc = CHILD_PROCESS_INIT;
872 char *hook;
873 hook = find_hook("post-update");
875 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
876 if (cmd->error_string || cmd->did_not_exist)
877 continue;
878 argc++;
879 }
880 if (!argc || !hook)
881 return;
882 argv = xmalloc(sizeof(*argv) * (2 + argc));
884 argv[0] = hook;
885 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
887 if (cmd->error_string || cmd->did_not_exist)
888 continue;
889 argv[argc] = xstrdup(cmd->ref_name);
890 argc++;
891 }
892 argv[argc] = NULL;
893 proc.no_stdin = 1;
895 proc.stdout_to_stderr = 1;
896 proc.err = use_sideband ? -1 : 0;
897 proc.argv = argv;
898 if (!start_command(&proc)) {
900 if (use_sideband)
901 copy_to_sideband(proc.err, -1, NULL);
902 finish_command(&proc);
903 }
904}
905static void check_aliased_update(struct command *cmd, struct string_list *list)
907{
908 struct strbuf buf = STRBUF_INIT;
909 const char *dst_name;
910 struct string_list_item *item;
911 struct command *dst_cmd;
912 unsigned char sha1[20];
913 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
914 int flag;
915 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
917 dst_name = resolve_ref_unsafe(buf.buf, 0, sha1, &flag);
918 strbuf_release(&buf);
919 if (!(flag & REF_ISSYMREF))
921 return;
922 dst_name = strip_namespace(dst_name);
924 if (!dst_name) {
925 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
926 cmd->skip_update = 1;
927 cmd->error_string = "broken symref";
928 return;
929 }
930 if ((item = string_list_lookup(list, dst_name)) == NULL)
932 return;
933 cmd->skip_update = 1;
935 dst_cmd = (struct command *) item->util;
937 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
939 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
940 return;
941 dst_cmd->skip_update = 1;
943 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
945 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
946 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
947 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
948 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
949 " its target '%s' (%s..%s)",
950 cmd->ref_name, cmd_oldh, cmd_newh,
951 dst_cmd->ref_name, dst_oldh, dst_newh);
952 cmd->error_string = dst_cmd->error_string =
954 "inconsistent aliased update";
955}
956static void check_aliased_updates(struct command *commands)
958{
959 struct command *cmd;
960 struct string_list ref_list = STRING_LIST_INIT_NODUP;
961 for (cmd = commands; cmd; cmd = cmd->next) {
963 struct string_list_item *item =
964 string_list_append(&ref_list, cmd->ref_name);
965 item->util = (void *)cmd;
966 }
967 sort_string_list(&ref_list);
968 for (cmd = commands; cmd; cmd = cmd->next) {
970 if (!cmd->error_string)
971 check_aliased_update(cmd, &ref_list);
972 }
973 string_list_clear(&ref_list, 0);
975}
976static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
978{
979 struct command **cmd_list = cb_data;
980 struct command *cmd = *cmd_list;
981 if (!cmd || is_null_sha1(cmd->new_sha1))
983 return -1; /* end of list */
984 *cmd_list = NULL; /* this returns only one */
985 hashcpy(sha1, cmd->new_sha1);
986 return 0;
987}
988static void set_connectivity_errors(struct command *commands,
990 struct shallow_info *si)
991{
992 struct command *cmd;
993 for (cmd = commands; cmd; cmd = cmd->next) {
995 struct command *singleton = cmd;
996 if (shallow_update && si->shallow_ref[cmd->index])
997 /* to be checked in update_shallow_ref() */
998 continue;
999 if (!check_everything_connected(command_singleton_iterator,
1000 0, &singleton))
1001 continue;
1002 cmd->error_string = "missing necessary objects";
1003 }
1004}
1005struct iterate_data {
1007 struct command *cmds;
1008 struct shallow_info *si;
1009};
1010static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
1012{
1013 struct iterate_data *data = cb_data;
1014 struct command **cmd_list = &data->cmds;
1015 struct command *cmd = *cmd_list;
1016 for (; cmd; cmd = cmd->next) {
1018 if (shallow_update && data->si->shallow_ref[cmd->index])
1019 /* to be checked in update_shallow_ref() */
1020 continue;
1021 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
1022 hashcpy(sha1, cmd->new_sha1);
1023 *cmd_list = cmd->next;
1024 return 0;
1025 }
1026 }
1027 *cmd_list = NULL;
1028 return -1; /* end of list */
1029}
1030static void reject_updates_to_hidden(struct command *commands)
1032{
1033 struct command *cmd;
1034 for (cmd = commands; cmd; cmd = cmd->next) {
1036 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
1037 continue;
1038 if (is_null_sha1(cmd->new_sha1))
1039 cmd->error_string = "deny deleting a hidden ref";
1040 else
1041 cmd->error_string = "deny updating a hidden ref";
1042 }
1043}
1044static int should_process_cmd(struct command *cmd)
1046{
1047 return !cmd->error_string && !cmd->skip_update;
1048}
1049static void warn_if_skipped_connectivity_check(struct command *commands,
1051 struct shallow_info *si)
1052{
1053 struct command *cmd;
1054 int checked_connectivity = 1;
1055 for (cmd = commands; cmd; cmd = cmd->next) {
1057 if (should_process_cmd(cmd) && si->shallow_ref[cmd->index]) {
1058 error("BUG: connectivity check has not been run on ref %s",
1059 cmd->ref_name);
1060 checked_connectivity = 0;
1061 }
1062 }
1063 if (!checked_connectivity)
1064 die("BUG: connectivity check skipped???");
1065}
1066static void execute_commands_non_atomic(struct command *commands,
1068 struct shallow_info *si)
1069{
1070 struct command *cmd;
1071 for (cmd = commands; cmd; cmd = cmd->next) {
1072 if (!should_process_cmd(cmd))
1073 continue;
1074 cmd->error_string = update(cmd, si);
1076 }
1077}
1078static void execute_commands(struct command *commands,
1080 const char *unpacker_error,
1081 struct shallow_info *si)
1082{
1083 struct command *cmd;
1084 unsigned char sha1[20];
1085 struct iterate_data data;
1086 if (unpacker_error) {
1088 for (cmd = commands; cmd; cmd = cmd->next)
1089 cmd->error_string = "unpacker error";
1090 return;
1091 }
1092 data.cmds = commands;
1094 data.si = si;
1095 if (check_everything_connected(iterate_receive_command_list, 0, &data))
1096 set_connectivity_errors(commands, si);
1097 reject_updates_to_hidden(commands);
1099 if (run_receive_hook(commands, "pre-receive", 0)) {
1101 for (cmd = commands; cmd; cmd = cmd->next) {
1102 if (!cmd->error_string)
1103 cmd->error_string = "pre-receive hook declined";
1104 }
1105 return;
1106 }
1107 check_aliased_updates(commands);
1109 free(head_name_to_free);
1111 head_name = head_name_to_free = resolve_refdup("HEAD", 0, sha1, NULL);
1112 execute_commands_non_atomic(commands, si);
1114 if (shallow_update)
1116 warn_if_skipped_connectivity_check(commands, si);
1117}
1118static struct command **queue_command(struct command **tail,
1120 const char *line,
1121 int linelen)
1122{
1123 unsigned char old_sha1[20], new_sha1[20];
1124 struct command *cmd;
1125 const char *refname;
1126 int reflen;
1127 if (linelen < 83 ||
1129 line[40] != ' ' ||
1130 line[81] != ' ' ||
1131 get_sha1_hex(line, old_sha1) ||
1132 get_sha1_hex(line + 41, new_sha1))
1133 die("protocol error: expected old/new/ref, got '%s'", line);
1134 refname = line + 82;
1136 reflen = linelen - 82;
1137 cmd = xcalloc(1, sizeof(struct command) + reflen + 1);
1138 hashcpy(cmd->old_sha1, old_sha1);
1139 hashcpy(cmd->new_sha1, new_sha1);
1140 memcpy(cmd->ref_name, refname, reflen);
1141 cmd->ref_name[reflen] = '\0';
1142 *tail = cmd;
1143 return &cmd->next;
1144}
1145static void queue_commands_from_cert(struct command **tail,
1147 struct strbuf *push_cert)
1148{
1149 const char *boc, *eoc;
1150 if (*tail)
1152 die("protocol error: got both push certificate and unsigned commands");
1153 boc = strstr(push_cert->buf, "\n\n");
1155 if (!boc)
1156 die("malformed push certificate %.*s", 100, push_cert->buf);
1157 else
1158 boc += 2;
1159 eoc = push_cert->buf + parse_signature(push_cert->buf, push_cert->len);
1160 while (boc < eoc) {
1162 const char *eol = memchr(boc, '\n', eoc - boc);
1163 tail = queue_command(tail, boc, eol ? eol - boc : eoc - eol);
1164 boc = eol ? eol + 1 : eoc;
1165 }
1166}
1167static struct command *read_head_info(struct sha1_array *shallow)
1169{
1170 struct command *commands = NULL;
1171 struct command **p = &commands;
1172 for (;;) {
1173 char *line;
1174 int len, linelen;
1175 line = packet_read_line(0, &len);
1177 if (!line)
1178 break;
1179 if (len == 48 && starts_with(line, "shallow ")) {
1181 unsigned char sha1[20];
1182 if (get_sha1_hex(line + 8, sha1))
1183 die("protocol error: expected shallow sha, got '%s'",
1184 line + 8);
1185 sha1_array_append(shallow, sha1);
1186 continue;
1187 }
1188 linelen = strlen(line);
1190 if (linelen < len) {
1191 const char *feature_list = line + linelen + 1;
1192 if (parse_feature_request(feature_list, "report-status"))
1193 report_status = 1;
1194 if (parse_feature_request(feature_list, "side-band-64k"))
1195 use_sideband = LARGE_PACKET_MAX;
1196 if (parse_feature_request(feature_list, "quiet"))
1197 quiet = 1;
1198 }
1199 if (!strcmp(line, "push-cert")) {
1201 int true_flush = 0;
1202 char certbuf[1024];
1203 for (;;) {
1205 len = packet_read(0, NULL, NULL,
1206 certbuf, sizeof(certbuf), 0);
1207 if (!len) {
1208 true_flush = 1;
1209 break;
1210 }
1211 if (!strcmp(certbuf, "push-cert-end\n"))
1212 break; /* end of cert */
1213 strbuf_addstr(&push_cert, certbuf);
1214 }
1215 if (true_flush)
1217 break;
1218 continue;
1219 }
1220 p = queue_command(p, line, linelen);
1222 }
1223 if (push_cert.len)
1225 queue_commands_from_cert(p, &push_cert);
1226 return commands;
1228}
1229static const char *parse_pack_header(struct pack_header *hdr)
1231{
1232 switch (read_pack_header(0, hdr)) {
1233 case PH_ERROR_EOF:
1234 return "eof before pack header was fully read";
1235 case PH_ERROR_PACK_SIGNATURE:
1237 return "protocol error (pack signature mismatch detected)";
1238 case PH_ERROR_PROTOCOL:
1240 return "protocol error (pack version unsupported)";
1241 default:
1243 return "unknown error in parse_pack_header";
1244 case 0:
1246 return NULL;
1247 }
1248}
1249static const char *pack_lockfile;
1251static const char *unpack(int err_fd, struct shallow_info *si)
1253{
1254 struct pack_header hdr;
1255 const char *hdr_err;
1256 int status;
1257 char hdr_arg[38];
1258 struct child_process child = CHILD_PROCESS_INIT;
1259 int fsck_objects = (receive_fsck_objects >= 0
1260 ? receive_fsck_objects
1261 : transfer_fsck_objects >= 0
1262 ? transfer_fsck_objects
1263 : 0);
1264 hdr_err = parse_pack_header(&hdr);
1266 if (hdr_err) {
1267 if (err_fd > 0)
1268 close(err_fd);
1269 return hdr_err;
1270 }
1271 snprintf(hdr_arg, sizeof(hdr_arg),
1272 "--pack_header=%"PRIu32",%"PRIu32,
1273 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
1274 if (si->nr_ours || si->nr_theirs) {
1276 alt_shallow_file = setup_temporary_shallow(si->shallow);
1277 argv_array_push(&child.args, "--shallow-file");
1278 argv_array_push(&child.args, alt_shallow_file);
1279 }
1280 if (ntohl(hdr.hdr_entries) < unpack_limit) {
1282 argv_array_pushl(&child.args, "unpack-objects", hdr_arg, NULL);
1283 if (quiet)
1284 argv_array_push(&child.args, "-q");
1285 if (fsck_objects)
1286 argv_array_push(&child.args, "--strict");
1287 child.no_stdout = 1;
1288 child.err = err_fd;
1289 child.git_cmd = 1;
1290 status = run_command(&child);
1291 if (status)
1292 return "unpack-objects abnormal exit";
1293 } else {
1294 int s;
1295 char keep_arg[256];
1296 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
1298 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
1299 strcpy(keep_arg + s, "localhost");
1300 argv_array_pushl(&child.args, "index-pack",
1302 "--stdin", hdr_arg, keep_arg, NULL);
1303 if (fsck_objects)
1304 argv_array_push(&child.args, "--strict");
1305 if (fix_thin)
1306 argv_array_push(&child.args, "--fix-thin");
1307 child.out = -1;
1308 child.err = err_fd;
1309 child.git_cmd = 1;
1310 status = start_command(&child);
1311 if (status)
1312 return "index-pack fork failed";
1313 pack_lockfile = index_pack_lockfile(child.out);
1314 close(child.out);
1315 status = finish_command(&child);
1316 if (status)
1317 return "index-pack abnormal exit";
1318 reprepare_packed_git();
1319 }
1320 return NULL;
1321}
1322static const char *unpack_with_sideband(struct shallow_info *si)
1324{
1325 struct async muxer;
1326 const char *ret;
1327 if (!use_sideband)
1329 return unpack(0, si);
1330 memset(&muxer, 0, sizeof(muxer));
1332 muxer.proc = copy_to_sideband;
1333 muxer.in = -1;
1334 if (start_async(&muxer))
1335 return NULL;
1336 ret = unpack(muxer.in, si);
1338 finish_async(&muxer);
1340 return ret;
1341}
1342static void prepare_shallow_update(struct command *commands,
1344 struct shallow_info *si)
1345{
1346 int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1347 si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1349 si->shallow->nr);
1350 assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1351 si->need_reachability_test =
1353 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1354 si->reachable =
1355 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1356 si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1357 for (i = 0; i < si->nr_ours; i++)
1359 si->need_reachability_test[si->ours[i]] = 1;
1360 for (i = 0; i < si->shallow->nr; i++) {
1362 if (!si->used_shallow[i])
1363 continue;
1364 for (j = 0; j < bitmap_size; j++) {
1365 if (!si->used_shallow[i][j])
1366 continue;
1367 si->need_reachability_test[i]++;
1368 for (k = 0; k < 32; k++)
1369 if (si->used_shallow[i][j] & (1 << k))
1370 si->shallow_ref[j * 32 + k]++;
1371 }
1372 /*
1374 * true for those associated with some refs and belong
1375 * in "ours" list aka "step 7 not done yet"
1376 */
1377 si->need_reachability_test[i] =
1378 si->need_reachability_test[i] > 1;
1379 }
1380 /*
1382 * keep hooks happy by forcing a temporary shallow file via
1383 * env variable because we can't add --shallow-file to every
1384 * command. check_everything_connected() will be done with
1385 * true .git/shallow though.
1386 */
1387 setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1388}
1389static void update_shallow_info(struct command *commands,
1391 struct shallow_info *si,
1392 struct sha1_array *ref)
1393{
1394 struct command *cmd;
1395 int *ref_status;
1396 remove_nonexistent_theirs_shallow(si);
1397 if (!si->nr_ours && !si->nr_theirs) {
1398 shallow_update = 0;
1399 return;
1400 }
1401 for (cmd = commands; cmd; cmd = cmd->next) {
1403 if (is_null_sha1(cmd->new_sha1))
1404 continue;
1405 sha1_array_append(ref, cmd->new_sha1);
1406 cmd->index = ref->nr - 1;
1407 }
1408 si->ref = ref;
1409 if (shallow_update) {
1411 prepare_shallow_update(commands, si);
1412 return;
1413 }
1414 ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1416 assign_shallow_commits_to_refs(si, NULL, ref_status);
1417 for (cmd = commands; cmd; cmd = cmd->next) {
1418 if (is_null_sha1(cmd->new_sha1))
1419 continue;
1420 if (ref_status[cmd->index]) {
1421 cmd->error_string = "shallow update not allowed";
1422 cmd->skip_update = 1;
1423 }
1424 }
1425 free(ref_status);
1426}
1427static void report(struct command *commands, const char *unpack_status)
1429{
1430 struct command *cmd;
1431 struct strbuf buf = STRBUF_INIT;
1432 packet_buf_write(&buf, "unpack %s\n",
1434 unpack_status ? unpack_status : "ok");
1435 for (cmd = commands; cmd; cmd = cmd->next) {
1436 if (!cmd->error_string)
1437 packet_buf_write(&buf, "ok %s\n",
1438 cmd->ref_name);
1439 else
1440 packet_buf_write(&buf, "ng %s %s\n",
1441 cmd->ref_name, cmd->error_string);
1442 }
1443 packet_buf_flush(&buf);
1444 if (use_sideband)
1446 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1447 else
1448 write_or_die(1, buf.buf, buf.len);
1449 strbuf_release(&buf);
1450}
1451static int delete_only(struct command *commands)
1453{
1454 struct command *cmd;
1455 for (cmd = commands; cmd; cmd = cmd->next) {
1456 if (!is_null_sha1(cmd->new_sha1))
1457 return 0;
1458 }
1459 return 1;
1460}
1461int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1463{
1464 int advertise_refs = 0;
1465 int i;
1466 struct command *commands;
1467 struct sha1_array shallow = SHA1_ARRAY_INIT;
1468 struct sha1_array ref = SHA1_ARRAY_INIT;
1469 struct shallow_info si;
1470 packet_trace_identity("receive-pack");
1472 argv++;
1474 for (i = 1; i < argc; i++) {
1475 const char *arg = *argv++;
1476 if (*arg == '-') {
1478 if (!strcmp(arg, "--quiet")) {
1479 quiet = 1;
1480 continue;
1481 }
1482 if (!strcmp(arg, "--advertise-refs")) {
1484 advertise_refs = 1;
1485 continue;
1486 }
1487 if (!strcmp(arg, "--stateless-rpc")) {
1488 stateless_rpc = 1;
1489 continue;
1490 }
1491 if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1492 fix_thin = 0;
1493 continue;
1494 }
1495 usage(receive_pack_usage);
1497 }
1498 if (service_dir)
1499 usage(receive_pack_usage);
1500 service_dir = arg;
1501 }
1502 if (!service_dir)
1503 usage(receive_pack_usage);
1504 setup_path();
1506 if (!enter_repo(service_dir, 0))
1508 die("'%s' does not appear to be a git repository", service_dir);
1509 git_config(receive_pack_config, NULL);
1511 if (cert_nonce_seed)
1512 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
1513 if (0 <= transfer_unpack_limit)
1515 unpack_limit = transfer_unpack_limit;
1516 else if (0 <= receive_unpack_limit)
1517 unpack_limit = receive_unpack_limit;
1518 if (advertise_refs || !stateless_rpc) {
1520 write_head_info();
1521 }
1522 if (advertise_refs)
1523 return 0;
1524 if ((commands = read_head_info(&shallow)) != NULL) {
1526 const char *unpack_status = NULL;
1527 prepare_shallow_info(&si, &shallow);
1529 if (!si.nr_ours && !si.nr_theirs)
1530 shallow_update = 0;
1531 if (!delete_only(commands)) {
1532 unpack_status = unpack_with_sideband(&si);
1533 update_shallow_info(commands, &si, &ref);
1534 }
1535 execute_commands(commands, unpack_status, &si);
1536 if (pack_lockfile)
1537 unlink_or_warn(pack_lockfile);
1538 if (report_status)
1539 report(commands, unpack_status);
1540 run_receive_hook(commands, "post-receive", 1);
1541 run_update_post_hook(commands);
1542 if (auto_gc) {
1543 const char *argv_gc_auto[] = {
1544 "gc", "--auto", "--quiet", NULL,
1545 };
1546 int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1547 run_command_v_opt(argv_gc_auto, opt);
1548 }
1549 if (auto_update_server_info)
1550 update_server_info(0);
1551 clear_shallow_info(&si);
1552 }
1553 if (use_sideband)
1554 packet_flush(1);
1555 sha1_array_clear(&shallow);
1556 sha1_array_clear(&ref);
1557 free((void *)push_cert_nonce);
1558 return 0;
1559}