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 advertise_atomic_push = 1;
41static int unpack_limit = 100;
42static int report_status;
43static int use_sideband;
44static int use_atomic;
45static int quiet;
46static int prefer_ofs_delta = 1;
47static int auto_update_server_info;
48static int auto_gc = 1;
49static int fix_thin = 1;
50static int stateless_rpc;
51static const char *service_dir;
52static const char *head_name;
53static void *head_name_to_free;
54static int sent_capabilities;
55static int shallow_update;
56static const char *alt_shallow_file;
57static struct strbuf push_cert = STRBUF_INIT;
58static unsigned char push_cert_sha1[20];
59static struct signature_check sigcheck;
60static const char *push_cert_nonce;
61static const char *cert_nonce_seed;
62static const char *NONCE_UNSOLICITED = "UNSOLICITED";
64static const char *NONCE_BAD = "BAD";
65static const char *NONCE_MISSING = "MISSING";
66static const char *NONCE_OK = "OK";
67static const char *NONCE_SLOP = "SLOP";
68static const char *nonce_status;
69static long nonce_stamp_slop;
70static unsigned long nonce_stamp_slop_limit;
71static struct ref_transaction *transaction;
72static enum deny_action parse_deny_action(const char *var, const char *value)
74{
75 if (value) {
76 if (!strcasecmp(value, "ignore"))
77 return DENY_IGNORE;
78 if (!strcasecmp(value, "warn"))
79 return DENY_WARN;
80 if (!strcasecmp(value, "refuse"))
81 return DENY_REFUSE;
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 if (strcmp(var, "receive.advertiseatomic") == 0) {
164 advertise_atomic_push = git_config_bool(var, value);
165 return 0;
166 }
167 return git_default_config(var, value, cb);
169}
170static void show_ref(const char *path, const unsigned char *sha1)
172{
173 if (ref_is_hidden(path))
174 return;
175 if (sent_capabilities) {
177 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
178 } else {
179 struct strbuf cap = STRBUF_INIT;
180 strbuf_addstr(&cap,
182 "report-status delete-refs side-band-64k quiet");
183 if (advertise_atomic_push)
184 strbuf_addstr(&cap, " atomic");
185 if (prefer_ofs_delta)
186 strbuf_addstr(&cap, " ofs-delta");
187 if (push_cert_nonce)
188 strbuf_addf(&cap, " push-cert=%s", push_cert_nonce);
189 strbuf_addf(&cap, " agent=%s", git_user_agent_sanitized());
190 packet_write(1, "%s %s%c%s\n",
191 sha1_to_hex(sha1), path, 0, cap.buf);
192 strbuf_release(&cap);
193 sent_capabilities = 1;
194 }
195}
196static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
198{
199 path = strip_namespace(path);
200 /*
201 * Advertise refs outside our current namespace as ".have"
202 * refs, so that the client can use them to minimize data
203 * transfer but will otherwise ignore them. This happens to
204 * cover ".have" that are thrown in by add_one_alternate_ref()
205 * to mark histories that are complete in our alternates as
206 * well.
207 */
208 if (!path)
209 path = ".have";
210 show_ref(path, sha1);
211 return 0;
212}
213static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
215{
216 show_ref(".have", sha1);
217}
218static void collect_one_alternate_ref(const struct ref *ref, void *data)
220{
221 struct sha1_array *sa = data;
222 sha1_array_append(sa, ref->old_sha1);
223}
224static void write_head_info(void)
226{
227 struct sha1_array sa = SHA1_ARRAY_INIT;
228 for_each_alternate_ref(collect_one_alternate_ref, &sa);
229 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
230 sha1_array_clear(&sa);
231 for_each_ref(show_ref_cb, NULL);
232 if (!sent_capabilities)
233 show_ref("capabilities^{}", null_sha1);
234 advertise_shallow_grafts(1);
236 /* EOF */
238 packet_flush(1);
239}
240struct command {
242 struct command *next;
243 const char *error_string;
244 unsigned int skip_update:1,
245 did_not_exist:1;
246 int index;
247 unsigned char old_sha1[20];
248 unsigned char new_sha1[20];
249 char ref_name[FLEX_ARRAY]; /* more */
250};
251static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
253static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
254static void report_message(const char *prefix, const char *err, va_list params)
256{
257 int sz = strlen(prefix);
258 char msg[4096];
259 strncpy(msg, prefix, sz);
261 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
262 if (sz > (sizeof(msg) - 1))
263 sz = sizeof(msg) - 1;
264 msg[sz++] = '\n';
265 if (use_sideband)
267 send_sideband(1, 2, msg, sz, use_sideband);
268 else
269 xwrite(2, msg, sz);
270}
271static void rp_warning(const char *err, ...)
273{
274 va_list params;
275 va_start(params, err);
276 report_message("warning: ", err, params);
277 va_end(params);
278}
279static void rp_error(const char *err, ...)
281{
282 va_list params;
283 va_start(params, err);
284 report_message("error: ", err, params);
285 va_end(params);
286}
287static int copy_to_sideband(int in, int out, void *arg)
289{
290 char data[128];
291 while (1) {
292 ssize_t sz = xread(in, data, sizeof(data));
293 if (sz <= 0)
294 break;
295 send_sideband(1, 2, data, sz, use_sideband);
296 }
297 close(in);
298 return 0;
299}
300#define HMAC_BLOCK_SIZE 64
302static void hmac_sha1(unsigned char *out,
304 const char *key_in, size_t key_len,
305 const char *text, size_t text_len)
306{
307 unsigned char key[HMAC_BLOCK_SIZE];
308 unsigned char k_ipad[HMAC_BLOCK_SIZE];
309 unsigned char k_opad[HMAC_BLOCK_SIZE];
310 int i;
311 git_SHA_CTX ctx;
312 /* RFC 2104 2. (1) */
314 memset(key, '\0', HMAC_BLOCK_SIZE);
315 if (HMAC_BLOCK_SIZE < key_len) {
316 git_SHA1_Init(&ctx);
317 git_SHA1_Update(&ctx, key_in, key_len);
318 git_SHA1_Final(key, &ctx);
319 } else {
320 memcpy(key, key_in, key_len);
321 }
322 /* RFC 2104 2. (2) & (5) */
324 for (i = 0; i < sizeof(key); i++) {
325 k_ipad[i] = key[i] ^ 0x36;
326 k_opad[i] = key[i] ^ 0x5c;
327 }
328 /* RFC 2104 2. (3) & (4) */
330 git_SHA1_Init(&ctx);
331 git_SHA1_Update(&ctx, k_ipad, sizeof(k_ipad));
332 git_SHA1_Update(&ctx, text, text_len);
333 git_SHA1_Final(out, &ctx);
334 /* RFC 2104 2. (6) & (7) */
336 git_SHA1_Init(&ctx);
337 git_SHA1_Update(&ctx, k_opad, sizeof(k_opad));
338 git_SHA1_Update(&ctx, out, 20);
339 git_SHA1_Final(out, &ctx);
340}
341static char *prepare_push_cert_nonce(const char *path, unsigned long stamp)
343{
344 struct strbuf buf = STRBUF_INIT;
345 unsigned char sha1[20];
346 strbuf_addf(&buf, "%s:%lu", path, stamp);
348 hmac_sha1(sha1, buf.buf, buf.len, cert_nonce_seed, strlen(cert_nonce_seed));;
349 strbuf_release(&buf);
350 /* RFC 2104 5. HMAC-SHA1-80 */
352 strbuf_addf(&buf, "%lu-%.*s", stamp, 20, sha1_to_hex(sha1));
353 return strbuf_detach(&buf, NULL);
354}
355/*
357 * NEEDSWORK: reuse find_commit_header() from jk/commit-author-parsing
358 * after dropping "_commit" from its name and possibly moving it out
359 * of commit.c
360 */
361static char *find_header(const char *msg, size_t len, const char *key)
362{
363 int key_len = strlen(key);
364 const char *line = msg;
365 while (line && line < msg + len) {
367 const char *eol = strchrnul(line, '\n');
368 if ((msg + len <= eol) || line == eol)
370 return NULL;
371 if (line + key_len < eol &&
372 !memcmp(line, key, key_len) && line[key_len] == ' ') {
373 int offset = key_len + 1;
374 return xmemdupz(line + offset, (eol - line) - offset);
375 }
376 line = *eol ? eol + 1 : NULL;
377 }
378 return NULL;
379}
380static const char *check_nonce(const char *buf, size_t len)
382{
383 char *nonce = find_header(buf, len, "nonce");
384 unsigned long stamp, ostamp;
385 char *bohmac, *expect = NULL;
386 const char *retval = NONCE_BAD;
387 if (!nonce) {
389 retval = NONCE_MISSING;
390 goto leave;
391 } else if (!push_cert_nonce) {
392 retval = NONCE_UNSOLICITED;
393 goto leave;
394 } else if (!strcmp(push_cert_nonce, nonce)) {
395 retval = NONCE_OK;
396 goto leave;
397 }
398 if (!stateless_rpc) {
400 /* returned nonce MUST match what we gave out earlier */
401 retval = NONCE_BAD;
402 goto leave;
403 }
404 /*
406 * In stateless mode, we may be receiving a nonce issued by
407 * another instance of the server that serving the same
408 * repository, and the timestamps may not match, but the
409 * nonce-seed and dir should match, so we can recompute and
410 * report the time slop.
411 *
412 * In addition, when a nonce issued by another instance has
413 * timestamp within receive.certnonceslop seconds, we pretend
414 * as if we issued that nonce when reporting to the hook.
415 */
416 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
418 if (*nonce <= '0' || '9' < *nonce) {
419 retval = NONCE_BAD;
420 goto leave;
421 }
422 stamp = strtoul(nonce, &bohmac, 10);
423 if (bohmac == nonce || bohmac[0] != '-') {
424 retval = NONCE_BAD;
425 goto leave;
426 }
427 expect = prepare_push_cert_nonce(service_dir, stamp);
429 if (strcmp(expect, nonce)) {
430 /* Not what we would have signed earlier */
431 retval = NONCE_BAD;
432 goto leave;
433 }
434 /*
436 * By how many seconds is this nonce stale? Negative value
437 * would mean it was issued by another server with its clock
438 * skewed in the future.
439 */
440 ostamp = strtoul(push_cert_nonce, NULL, 10);
441 nonce_stamp_slop = (long)ostamp - (long)stamp;
442 if (nonce_stamp_slop_limit &&
444 abs(nonce_stamp_slop) <= nonce_stamp_slop_limit) {
445 /*
446 * Pretend as if the received nonce (which passes the
447 * HMAC check, so it is not a forged by third-party)
448 * is what we issued.
449 */
450 free((void *)push_cert_nonce);
451 push_cert_nonce = xstrdup(nonce);
452 retval = NONCE_OK;
453 } else {
454 retval = NONCE_SLOP;
455 }
456leave:
458 free(nonce);
459 free(expect);
460 return retval;
461}
462static void prepare_push_cert_sha1(struct child_process *proc)
464{
465 static int already_done;
466 if (!push_cert.len)
468 return;
469 if (!already_done) {
471 struct strbuf gpg_output = STRBUF_INIT;
472 struct strbuf gpg_status = STRBUF_INIT;
473 int bogs /* beginning_of_gpg_sig */;
474 already_done = 1;
476 if (write_sha1_file(push_cert.buf, push_cert.len, "blob", push_cert_sha1))
477 hashclr(push_cert_sha1);
478 memset(&sigcheck, '\0', sizeof(sigcheck));
480 sigcheck.result = 'N';
481 bogs = parse_signature(push_cert.buf, push_cert.len);
483 if (verify_signed_buffer(push_cert.buf, bogs,
484 push_cert.buf + bogs, push_cert.len - bogs,
485 &gpg_output, &gpg_status) < 0) {
486 ; /* error running gpg */
487 } else {
488 sigcheck.payload = push_cert.buf;
489 sigcheck.gpg_output = gpg_output.buf;
490 sigcheck.gpg_status = gpg_status.buf;
491 parse_gpg_output(&sigcheck);
492 }
493 strbuf_release(&gpg_output);
495 strbuf_release(&gpg_status);
496 nonce_status = check_nonce(push_cert.buf, bogs);
497 }
498 if (!is_null_sha1(push_cert_sha1)) {
499 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT=%s",
500 sha1_to_hex(push_cert_sha1));
501 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_SIGNER=%s",
502 sigcheck.signer ? sigcheck.signer : "");
503 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_KEY=%s",
504 sigcheck.key ? sigcheck.key : "");
505 argv_array_pushf(&proc->env_array, "GIT_PUSH_CERT_STATUS=%c",
506 sigcheck.result);
507 if (push_cert_nonce) {
508 argv_array_pushf(&proc->env_array,
509 "GIT_PUSH_CERT_NONCE=%s",
510 push_cert_nonce);
511 argv_array_pushf(&proc->env_array,
512 "GIT_PUSH_CERT_NONCE_STATUS=%s",
513 nonce_status);
514 if (nonce_status == NONCE_SLOP)
515 argv_array_pushf(&proc->env_array,
516 "GIT_PUSH_CERT_NONCE_SLOP=%ld",
517 nonce_stamp_slop);
518 }
519 }
520}
521typedef int (*feed_fn)(void *, const char **, size_t *);
523static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
524{
525 struct child_process proc = CHILD_PROCESS_INIT;
526 struct async muxer;
527 const char *argv[2];
528 int code;
529 argv[0] = find_hook(hook_name);
531 if (!argv[0])
532 return 0;
533 argv[1] = NULL;
535 proc.argv = argv;
537 proc.in = -1;
538 proc.stdout_to_stderr = 1;
539 if (use_sideband) {
541 memset(&muxer, 0, sizeof(muxer));
542 muxer.proc = copy_to_sideband;
543 muxer.in = -1;
544 code = start_async(&muxer);
545 if (code)
546 return code;
547 proc.err = muxer.in;
548 }
549 prepare_push_cert_sha1(&proc);
551 code = start_command(&proc);
553 if (code) {
554 if (use_sideband)
555 finish_async(&muxer);
556 return code;
557 }
558 sigchain_push(SIGPIPE, SIG_IGN);
560 while (1) {
562 const char *buf;
563 size_t n;
564 if (feed(feed_state, &buf, &n))
565 break;
566 if (write_in_full(proc.in, buf, n) != n)
567 break;
568 }
569 close(proc.in);
570 if (use_sideband)
571 finish_async(&muxer);
572 sigchain_pop(SIGPIPE);
574 return finish_command(&proc);
576}
577struct receive_hook_feed_state {
579 struct command *cmd;
580 int skip_broken;
581 struct strbuf buf;
582};
583static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
585{
586 struct receive_hook_feed_state *state = state_;
587 struct command *cmd = state->cmd;
588 while (cmd &&
590 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
591 cmd = cmd->next;
592 if (!cmd)
593 return -1; /* EOF */
594 strbuf_reset(&state->buf);
595 strbuf_addf(&state->buf, "%s %s %s\n",
596 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
597 cmd->ref_name);
598 state->cmd = cmd->next;
599 if (bufp) {
600 *bufp = state->buf.buf;
601 *sizep = state->buf.len;
602 }
603 return 0;
604}
605static int run_receive_hook(struct command *commands, const char *hook_name,
607 int skip_broken)
608{
609 struct receive_hook_feed_state state;
610 int status;
611 strbuf_init(&state.buf, 0);
613 state.cmd = commands;
614 state.skip_broken = skip_broken;
615 if (feed_receive_hook(&state, NULL, NULL))
616 return 0;
617 state.cmd = commands;
618 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
619 strbuf_release(&state.buf);
620 return status;
621}
622static int run_update_hook(struct command *cmd)
624{
625 const char *argv[5];
626 struct child_process proc = CHILD_PROCESS_INIT;
627 int code;
628 argv[0] = find_hook("update");
630 if (!argv[0])
631 return 0;
632 argv[1] = cmd->ref_name;
634 argv[2] = sha1_to_hex(cmd->old_sha1);
635 argv[3] = sha1_to_hex(cmd->new_sha1);
636 argv[4] = NULL;
637 proc.no_stdin = 1;
639 proc.stdout_to_stderr = 1;
640 proc.err = use_sideband ? -1 : 0;
641 proc.argv = argv;
642 code = start_command(&proc);
644 if (code)
645 return code;
646 if (use_sideband)
647 copy_to_sideband(proc.err, -1, NULL);
648 return finish_command(&proc);
649}
650static int is_ref_checked_out(const char *ref)
652{
653 if (is_bare_repository())
654 return 0;
655 if (!head_name)
657 return 0;
658 return !strcmp(head_name, ref);
659}
660static char *refuse_unconfigured_deny_msg[] = {
662 "By default, updating the current branch in a non-bare repository",
663 "is denied, because it will make the index and work tree inconsistent",
664 "with what you pushed, and will require 'git reset --hard' to match",
665 "the work tree to HEAD.",
666 "",
667 "You can set 'receive.denyCurrentBranch' configuration variable to",
668 "'ignore' or 'warn' in the remote repository to allow pushing into",
669 "its current branch; however, this is not recommended unless you",
670 "arranged to update its work tree to match what you pushed in some",
671 "other way.",
672 "",
673 "To squelch this message and still keep the default behaviour, set",
674 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
675};
676static void refuse_unconfigured_deny(void)
678{
679 int i;
680 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
681 rp_error("%s", refuse_unconfigured_deny_msg[i]);
682}
683static char *refuse_unconfigured_deny_delete_current_msg[] = {
685 "By default, deleting the current branch is denied, because the next",
686 "'git clone' won't result in any file checked out, causing confusion.",
687 "",
688 "You can set 'receive.denyDeleteCurrent' configuration variable to",
689 "'warn' or 'ignore' in the remote repository to allow deleting the",
690 "current branch, with or without a warning message.",
691 "",
692 "To squelch this message, you can set it to 'refuse'."
693};
694static void refuse_unconfigured_deny_delete_current(void)
696{
697 int i;
698 for (i = 0;
699 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
700 i++)
701 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
702}
703static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
705static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
706{
707 static struct lock_file shallow_lock;
708 struct sha1_array extra = SHA1_ARRAY_INIT;
709 const char *alt_file;
710 uint32_t mask = 1 << (cmd->index % 32);
711 int i;
712 trace_printf_key(&trace_shallow,
714 "shallow: update_shallow_ref %s\n", cmd->ref_name);
715 for (i = 0; i < si->shallow->nr; i++)
716 if (si->used_shallow[i] &&
717 (si->used_shallow[i][cmd->index / 32] & mask) &&
718 !delayed_reachability_test(si, i))
719 sha1_array_append(&extra, si->shallow->sha1[i]);
720 setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
722 if (check_shallow_connected(command_singleton_iterator,
723 0, cmd, alt_file)) {
724 rollback_lock_file(&shallow_lock);
725 sha1_array_clear(&extra);
726 return -1;
727 }
728 commit_lock_file(&shallow_lock);
730 /*
732 * Make sure setup_alternate_shallow() for the next ref does
733 * not lose these new roots..
734 */
735 for (i = 0; i < extra.nr; i++)
736 register_shallow(extra.sha1[i]);
737 si->shallow_ref[cmd->index] = 0;
739 sha1_array_clear(&extra);
740 return 0;
741}
742static const char *update(struct command *cmd, struct shallow_info *si)
744{
745 const char *name = cmd->ref_name;
746 struct strbuf namespaced_name_buf = STRBUF_INIT;
747 const char *namespaced_name;
748 unsigned char *old_sha1 = cmd->old_sha1;
749 unsigned char *new_sha1 = cmd->new_sha1;
750 /* only refs/... are allowed */
752 if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
753 rp_error("refusing to create funny ref '%s' remotely", name);
754 return "funny refname";
755 }
756 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
758 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
759 if (is_ref_checked_out(namespaced_name)) {
761 switch (deny_current_branch) {
762 case DENY_IGNORE:
763 break;
764 case DENY_WARN:
765 rp_warning("updating the current branch");
766 break;
767 case DENY_REFUSE:
768 case DENY_UNCONFIGURED:
769 rp_error("refusing to update checked out branch: %s", name);
770 if (deny_current_branch == DENY_UNCONFIGURED)
771 refuse_unconfigured_deny();
772 return "branch is currently checked out";
773 }
774 }
775 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
777 error("unpack should have generated %s, "
778 "but I can't find it!", sha1_to_hex(new_sha1));
779 return "bad pack";
780 }
781 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
783 if (deny_deletes && starts_with(name, "refs/heads/")) {
784 rp_error("denying ref deletion for %s", name);
785 return "deletion prohibited";
786 }
787 if (!strcmp(namespaced_name, head_name)) {
789 switch (deny_delete_current) {
790 case DENY_IGNORE:
791 break;
792 case DENY_WARN:
793 rp_warning("deleting the current branch");
794 break;
795 case DENY_REFUSE:
796 case DENY_UNCONFIGURED:
797 if (deny_delete_current == DENY_UNCONFIGURED)
798 refuse_unconfigured_deny_delete_current();
799 rp_error("refusing to delete the current branch: %s", name);
800 return "deletion of the current branch prohibited";
801 }
802 }
803 }
804 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
806 !is_null_sha1(old_sha1) &&
807 starts_with(name, "refs/heads/")) {
808 struct object *old_object, *new_object;
809 struct commit *old_commit, *new_commit;
810 old_object = parse_object(old_sha1);
812 new_object = parse_object(new_sha1);
813 if (!old_object || !new_object ||
815 old_object->type != OBJ_COMMIT ||
816 new_object->type != OBJ_COMMIT) {
817 error("bad sha1 objects for %s", name);
818 return "bad ref";
819 }
820 old_commit = (struct commit *)old_object;
821 new_commit = (struct commit *)new_object;
822 if (!in_merge_bases(old_commit, new_commit)) {
823 rp_error("denying non-fast-forward %s"
824 " (you should pull first)", name);
825 return "non-fast-forward";
826 }
827 }
828 if (run_update_hook(cmd)) {
829 rp_error("hook declined to update %s", name);
830 return "hook declined";
831 }
832 if (is_null_sha1(new_sha1)) {
834 struct strbuf err = STRBUF_INIT;
835 if (!parse_object(old_sha1)) {
836 old_sha1 = NULL;
837 if (ref_exists(name)) {
838 rp_warning("Allowing deletion of corrupt ref.");
839 } else {
840 rp_warning("Deleting a non-existent ref.");
841 cmd->did_not_exist = 1;
842 }
843 }
844 if (ref_transaction_delete(transaction,
845 namespaced_name,
846 old_sha1,
847 0, old_sha1 != NULL,
848 "push", &err)) {
849 rp_error("%s", err.buf);
850 strbuf_release(&err);
851 return "failed to delete";
852 }
853 strbuf_release(&err);
854 return NULL; /* good */
855 }
856 else {
857 struct strbuf err = STRBUF_INIT;
858 if (shallow_update && si->shallow_ref[cmd->index] &&
859 update_shallow_ref(cmd, si))
860 return "shallow error";
861 if (ref_transaction_update(transaction,
863 namespaced_name,
864 new_sha1, old_sha1,
865 0, 1, "push",
866 &err)) {
867 rp_error("%s", err.buf);
868 strbuf_release(&err);
869 return "failed to update ref";
871 }
872 strbuf_release(&err);
873 return NULL; /* good */
875 }
876}
877static void run_update_post_hook(struct command *commands)
879{
880 struct command *cmd;
881 int argc;
882 const char **argv;
883 struct child_process proc = CHILD_PROCESS_INIT;
884 char *hook;
885 hook = find_hook("post-update");
887 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
888 if (cmd->error_string || cmd->did_not_exist)
889 continue;
890 argc++;
891 }
892 if (!argc || !hook)
893 return;
894 argv = xmalloc(sizeof(*argv) * (2 + argc));
896 argv[0] = hook;
897 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
899 if (cmd->error_string || cmd->did_not_exist)
900 continue;
901 argv[argc] = xstrdup(cmd->ref_name);
902 argc++;
903 }
904 argv[argc] = NULL;
905 proc.no_stdin = 1;
907 proc.stdout_to_stderr = 1;
908 proc.err = use_sideband ? -1 : 0;
909 proc.argv = argv;
910 if (!start_command(&proc)) {
912 if (use_sideband)
913 copy_to_sideband(proc.err, -1, NULL);
914 finish_command(&proc);
915 }
916}
917static void check_aliased_update(struct command *cmd, struct string_list *list)
919{
920 struct strbuf buf = STRBUF_INIT;
921 const char *dst_name;
922 struct string_list_item *item;
923 struct command *dst_cmd;
924 unsigned char sha1[20];
925 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
926 int flag;
927 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
929 dst_name = resolve_ref_unsafe(buf.buf, 0, sha1, &flag);
930 strbuf_release(&buf);
931 if (!(flag & REF_ISSYMREF))
933 return;
934 dst_name = strip_namespace(dst_name);
936 if (!dst_name) {
937 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
938 cmd->skip_update = 1;
939 cmd->error_string = "broken symref";
940 return;
941 }
942 if ((item = string_list_lookup(list, dst_name)) == NULL)
944 return;
945 cmd->skip_update = 1;
947 dst_cmd = (struct command *) item->util;
949 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
951 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
952 return;
953 dst_cmd->skip_update = 1;
955 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
957 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
958 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
959 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
960 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
961 " its target '%s' (%s..%s)",
962 cmd->ref_name, cmd_oldh, cmd_newh,
963 dst_cmd->ref_name, dst_oldh, dst_newh);
964 cmd->error_string = dst_cmd->error_string =
966 "inconsistent aliased update";
967}
968static void check_aliased_updates(struct command *commands)
970{
971 struct command *cmd;
972 struct string_list ref_list = STRING_LIST_INIT_NODUP;
973 for (cmd = commands; cmd; cmd = cmd->next) {
975 struct string_list_item *item =
976 string_list_append(&ref_list, cmd->ref_name);
977 item->util = (void *)cmd;
978 }
979 sort_string_list(&ref_list);
980 for (cmd = commands; cmd; cmd = cmd->next) {
982 if (!cmd->error_string)
983 check_aliased_update(cmd, &ref_list);
984 }
985 string_list_clear(&ref_list, 0);
987}
988static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
990{
991 struct command **cmd_list = cb_data;
992 struct command *cmd = *cmd_list;
993 if (!cmd || is_null_sha1(cmd->new_sha1))
995 return -1; /* end of list */
996 *cmd_list = NULL; /* this returns only one */
997 hashcpy(sha1, cmd->new_sha1);
998 return 0;
999}
1000static void set_connectivity_errors(struct command *commands,
1002 struct shallow_info *si)
1003{
1004 struct command *cmd;
1005 for (cmd = commands; cmd; cmd = cmd->next) {
1007 struct command *singleton = cmd;
1008 if (shallow_update && si->shallow_ref[cmd->index])
1009 /* to be checked in update_shallow_ref() */
1010 continue;
1011 if (!check_everything_connected(command_singleton_iterator,
1012 0, &singleton))
1013 continue;
1014 cmd->error_string = "missing necessary objects";
1015 }
1016}
1017struct iterate_data {
1019 struct command *cmds;
1020 struct shallow_info *si;
1021};
1022static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
1024{
1025 struct iterate_data *data = cb_data;
1026 struct command **cmd_list = &data->cmds;
1027 struct command *cmd = *cmd_list;
1028 for (; cmd; cmd = cmd->next) {
1030 if (shallow_update && data->si->shallow_ref[cmd->index])
1031 /* to be checked in update_shallow_ref() */
1032 continue;
1033 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
1034 hashcpy(sha1, cmd->new_sha1);
1035 *cmd_list = cmd->next;
1036 return 0;
1037 }
1038 }
1039 *cmd_list = NULL;
1040 return -1; /* end of list */
1041}
1042static void reject_updates_to_hidden(struct command *commands)
1044{
1045 struct command *cmd;
1046 for (cmd = commands; cmd; cmd = cmd->next) {
1048 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
1049 continue;
1050 if (is_null_sha1(cmd->new_sha1))
1051 cmd->error_string = "deny deleting a hidden ref";
1052 else
1053 cmd->error_string = "deny updating a hidden ref";
1054 }
1055}
1056static int should_process_cmd(struct command *cmd)
1058{
1059 return !cmd->error_string && !cmd->skip_update;
1060}
1061static void warn_if_skipped_connectivity_check(struct command *commands,
1063 struct shallow_info *si)
1064{
1065 struct command *cmd;
1066 int checked_connectivity = 1;
1067 for (cmd = commands; cmd; cmd = cmd->next) {
1069 if (should_process_cmd(cmd) && si->shallow_ref[cmd->index]) {
1070 error("BUG: connectivity check has not been run on ref %s",
1071 cmd->ref_name);
1072 checked_connectivity = 0;
1073 }
1074 }
1075 if (!checked_connectivity)
1076 die("BUG: connectivity check skipped???");
1077}
1078static void execute_commands_non_atomic(struct command *commands,
1080 struct shallow_info *si)
1081{
1082 struct command *cmd;
1083 struct strbuf err = STRBUF_INIT;
1084 for (cmd = commands; cmd; cmd = cmd->next) {
1086 if (!should_process_cmd(cmd))
1087 continue;
1088 transaction = ref_transaction_begin(&err);
1090 if (!transaction) {
1091 rp_error("%s", err.buf);
1092 strbuf_reset(&err);
1093 cmd->error_string = "transaction failed to start";
1094 continue;
1095 }
1096 cmd->error_string = update(cmd, si);
1098 if (!cmd->error_string
1100 && ref_transaction_commit(transaction, &err)) {
1101 rp_error("%s", err.buf);
1102 strbuf_reset(&err);
1103 cmd->error_string = "failed to update ref";
1104 }
1105 ref_transaction_free(transaction);
1106 }
1107 strbuf_release(&err);
1108}
1109static void execute_commands_atomic(struct command *commands,
1111 struct shallow_info *si)
1112{
1113 struct command *cmd;
1114 struct strbuf err = STRBUF_INIT;
1115 const char *reported_error = "atomic push failure";
1116 transaction = ref_transaction_begin(&err);
1118 if (!transaction) {
1119 rp_error("%s", err.buf);
1120 strbuf_reset(&err);
1121 reported_error = "transaction failed to start";
1122 goto failure;
1123 }
1124 for (cmd = commands; cmd; cmd = cmd->next) {
1126 if (!should_process_cmd(cmd))
1127 continue;
1128 cmd->error_string = update(cmd, si);
1130 if (cmd->error_string)
1132 goto failure;
1133 }
1134 if (ref_transaction_commit(transaction, &err)) {
1136 rp_error("%s", err.buf);
1137 reported_error = "atomic transaction failed";
1138 goto failure;
1139 }
1140 goto cleanup;
1141failure:
1143 for (cmd = commands; cmd; cmd = cmd->next)
1144 if (!cmd->error_string)
1145 cmd->error_string = reported_error;
1146cleanup:
1148 ref_transaction_free(transaction);
1149 strbuf_release(&err);
1150}
1151static void execute_commands(struct command *commands,
1153 const char *unpacker_error,
1154 struct shallow_info *si)
1155{
1156 struct command *cmd;
1157 unsigned char sha1[20];
1158 struct iterate_data data;
1159 if (unpacker_error) {
1161 for (cmd = commands; cmd; cmd = cmd->next)
1162 cmd->error_string = "unpacker error";
1163 return;
1164 }
1165 data.cmds = commands;
1167 data.si = si;
1168 if (check_everything_connected(iterate_receive_command_list, 0, &data))
1169 set_connectivity_errors(commands, si);
1170 reject_updates_to_hidden(commands);
1172 if (run_receive_hook(commands, "pre-receive", 0)) {
1174 for (cmd = commands; cmd; cmd = cmd->next) {
1175 if (!cmd->error_string)
1176 cmd->error_string = "pre-receive hook declined";
1177 }
1178 return;
1179 }
1180 check_aliased_updates(commands);
1182 free(head_name_to_free);
1184 head_name = head_name_to_free = resolve_refdup("HEAD", 0, sha1, NULL);
1185 if (use_atomic)
1187 execute_commands_atomic(commands, si);
1188 else
1189 execute_commands_non_atomic(commands, si);
1190 if (shallow_update)
1192 warn_if_skipped_connectivity_check(commands, si);
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 if (advertise_atomic_push
1275 && parse_feature_request(feature_list, "atomic"))
1276 use_atomic = 1;
1277 }
1278 if (!strcmp(line, "push-cert")) {
1280 int true_flush = 0;
1281 char certbuf[1024];
1282 for (;;) {
1284 len = packet_read(0, NULL, NULL,
1285 certbuf, sizeof(certbuf), 0);
1286 if (!len) {
1287 true_flush = 1;
1288 break;
1289 }
1290 if (!strcmp(certbuf, "push-cert-end\n"))
1291 break; /* end of cert */
1292 strbuf_addstr(&push_cert, certbuf);
1293 }
1294 if (true_flush)
1296 break;
1297 continue;
1298 }
1299 p = queue_command(p, line, linelen);
1301 }
1302 if (push_cert.len)
1304 queue_commands_from_cert(p, &push_cert);
1305 return commands;
1307}
1308static const char *parse_pack_header(struct pack_header *hdr)
1310{
1311 switch (read_pack_header(0, hdr)) {
1312 case PH_ERROR_EOF:
1313 return "eof before pack header was fully read";
1314 case PH_ERROR_PACK_SIGNATURE:
1316 return "protocol error (pack signature mismatch detected)";
1317 case PH_ERROR_PROTOCOL:
1319 return "protocol error (pack version unsupported)";
1320 default:
1322 return "unknown error in parse_pack_header";
1323 case 0:
1325 return NULL;
1326 }
1327}
1328static const char *pack_lockfile;
1330static const char *unpack(int err_fd, struct shallow_info *si)
1332{
1333 struct pack_header hdr;
1334 const char *hdr_err;
1335 int status;
1336 char hdr_arg[38];
1337 struct child_process child = CHILD_PROCESS_INIT;
1338 int fsck_objects = (receive_fsck_objects >= 0
1339 ? receive_fsck_objects
1340 : transfer_fsck_objects >= 0
1341 ? transfer_fsck_objects
1342 : 0);
1343 hdr_err = parse_pack_header(&hdr);
1345 if (hdr_err) {
1346 if (err_fd > 0)
1347 close(err_fd);
1348 return hdr_err;
1349 }
1350 snprintf(hdr_arg, sizeof(hdr_arg),
1351 "--pack_header=%"PRIu32",%"PRIu32,
1352 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
1353 if (si->nr_ours || si->nr_theirs) {
1355 alt_shallow_file = setup_temporary_shallow(si->shallow);
1356 argv_array_push(&child.args, "--shallow-file");
1357 argv_array_push(&child.args, alt_shallow_file);
1358 }
1359 if (ntohl(hdr.hdr_entries) < unpack_limit) {
1361 argv_array_pushl(&child.args, "unpack-objects", hdr_arg, NULL);
1362 if (quiet)
1363 argv_array_push(&child.args, "-q");
1364 if (fsck_objects)
1365 argv_array_push(&child.args, "--strict");
1366 child.no_stdout = 1;
1367 child.err = err_fd;
1368 child.git_cmd = 1;
1369 status = run_command(&child);
1370 if (status)
1371 return "unpack-objects abnormal exit";
1372 } else {
1373 int s;
1374 char keep_arg[256];
1375 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
1377 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
1378 strcpy(keep_arg + s, "localhost");
1379 argv_array_pushl(&child.args, "index-pack",
1381 "--stdin", hdr_arg, keep_arg, NULL);
1382 if (fsck_objects)
1383 argv_array_push(&child.args, "--strict");
1384 if (fix_thin)
1385 argv_array_push(&child.args, "--fix-thin");
1386 child.out = -1;
1387 child.err = err_fd;
1388 child.git_cmd = 1;
1389 status = start_command(&child);
1390 if (status)
1391 return "index-pack fork failed";
1392 pack_lockfile = index_pack_lockfile(child.out);
1393 close(child.out);
1394 status = finish_command(&child);
1395 if (status)
1396 return "index-pack abnormal exit";
1397 reprepare_packed_git();
1398 }
1399 return NULL;
1400}
1401static const char *unpack_with_sideband(struct shallow_info *si)
1403{
1404 struct async muxer;
1405 const char *ret;
1406 if (!use_sideband)
1408 return unpack(0, si);
1409 memset(&muxer, 0, sizeof(muxer));
1411 muxer.proc = copy_to_sideband;
1412 muxer.in = -1;
1413 if (start_async(&muxer))
1414 return NULL;
1415 ret = unpack(muxer.in, si);
1417 finish_async(&muxer);
1419 return ret;
1420}
1421static void prepare_shallow_update(struct command *commands,
1423 struct shallow_info *si)
1424{
1425 int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1426 si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1428 si->shallow->nr);
1429 assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1430 si->need_reachability_test =
1432 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1433 si->reachable =
1434 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1435 si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1436 for (i = 0; i < si->nr_ours; i++)
1438 si->need_reachability_test[si->ours[i]] = 1;
1439 for (i = 0; i < si->shallow->nr; i++) {
1441 if (!si->used_shallow[i])
1442 continue;
1443 for (j = 0; j < bitmap_size; j++) {
1444 if (!si->used_shallow[i][j])
1445 continue;
1446 si->need_reachability_test[i]++;
1447 for (k = 0; k < 32; k++)
1448 if (si->used_shallow[i][j] & (1 << k))
1449 si->shallow_ref[j * 32 + k]++;
1450 }
1451 /*
1453 * true for those associated with some refs and belong
1454 * in "ours" list aka "step 7 not done yet"
1455 */
1456 si->need_reachability_test[i] =
1457 si->need_reachability_test[i] > 1;
1458 }
1459 /*
1461 * keep hooks happy by forcing a temporary shallow file via
1462 * env variable because we can't add --shallow-file to every
1463 * command. check_everything_connected() will be done with
1464 * true .git/shallow though.
1465 */
1466 setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1467}
1468static void update_shallow_info(struct command *commands,
1470 struct shallow_info *si,
1471 struct sha1_array *ref)
1472{
1473 struct command *cmd;
1474 int *ref_status;
1475 remove_nonexistent_theirs_shallow(si);
1476 if (!si->nr_ours && !si->nr_theirs) {
1477 shallow_update = 0;
1478 return;
1479 }
1480 for (cmd = commands; cmd; cmd = cmd->next) {
1482 if (is_null_sha1(cmd->new_sha1))
1483 continue;
1484 sha1_array_append(ref, cmd->new_sha1);
1485 cmd->index = ref->nr - 1;
1486 }
1487 si->ref = ref;
1488 if (shallow_update) {
1490 prepare_shallow_update(commands, si);
1491 return;
1492 }
1493 ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1495 assign_shallow_commits_to_refs(si, NULL, ref_status);
1496 for (cmd = commands; cmd; cmd = cmd->next) {
1497 if (is_null_sha1(cmd->new_sha1))
1498 continue;
1499 if (ref_status[cmd->index]) {
1500 cmd->error_string = "shallow update not allowed";
1501 cmd->skip_update = 1;
1502 }
1503 }
1504 free(ref_status);
1505}
1506static void report(struct command *commands, const char *unpack_status)
1508{
1509 struct command *cmd;
1510 struct strbuf buf = STRBUF_INIT;
1511 packet_buf_write(&buf, "unpack %s\n",
1513 unpack_status ? unpack_status : "ok");
1514 for (cmd = commands; cmd; cmd = cmd->next) {
1515 if (!cmd->error_string)
1516 packet_buf_write(&buf, "ok %s\n",
1517 cmd->ref_name);
1518 else
1519 packet_buf_write(&buf, "ng %s %s\n",
1520 cmd->ref_name, cmd->error_string);
1521 }
1522 packet_buf_flush(&buf);
1523 if (use_sideband)
1525 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1526 else
1527 write_or_die(1, buf.buf, buf.len);
1528 strbuf_release(&buf);
1529}
1530static int delete_only(struct command *commands)
1532{
1533 struct command *cmd;
1534 for (cmd = commands; cmd; cmd = cmd->next) {
1535 if (!is_null_sha1(cmd->new_sha1))
1536 return 0;
1537 }
1538 return 1;
1539}
1540int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1542{
1543 int advertise_refs = 0;
1544 int i;
1545 struct command *commands;
1546 struct sha1_array shallow = SHA1_ARRAY_INIT;
1547 struct sha1_array ref = SHA1_ARRAY_INIT;
1548 struct shallow_info si;
1549 packet_trace_identity("receive-pack");
1551 argv++;
1553 for (i = 1; i < argc; i++) {
1554 const char *arg = *argv++;
1555 if (*arg == '-') {
1557 if (!strcmp(arg, "--quiet")) {
1558 quiet = 1;
1559 continue;
1560 }
1561 if (!strcmp(arg, "--advertise-refs")) {
1563 advertise_refs = 1;
1564 continue;
1565 }
1566 if (!strcmp(arg, "--stateless-rpc")) {
1567 stateless_rpc = 1;
1568 continue;
1569 }
1570 if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1571 fix_thin = 0;
1572 continue;
1573 }
1574 usage(receive_pack_usage);
1576 }
1577 if (service_dir)
1578 usage(receive_pack_usage);
1579 service_dir = arg;
1580 }
1581 if (!service_dir)
1582 usage(receive_pack_usage);
1583 setup_path();
1585 if (!enter_repo(service_dir, 0))
1587 die("'%s' does not appear to be a git repository", service_dir);
1588 git_config(receive_pack_config, NULL);
1590 if (cert_nonce_seed)
1591 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
1592 if (0 <= transfer_unpack_limit)
1594 unpack_limit = transfer_unpack_limit;
1595 else if (0 <= receive_unpack_limit)
1596 unpack_limit = receive_unpack_limit;
1597 if (advertise_refs || !stateless_rpc) {
1599 write_head_info();
1600 }
1601 if (advertise_refs)
1602 return 0;
1603 if ((commands = read_head_info(&shallow)) != NULL) {
1605 const char *unpack_status = NULL;
1606 prepare_shallow_info(&si, &shallow);
1608 if (!si.nr_ours && !si.nr_theirs)
1609 shallow_update = 0;
1610 if (!delete_only(commands)) {
1611 unpack_status = unpack_with_sideband(&si);
1612 update_shallow_info(commands, &si, &ref);
1613 }
1614 execute_commands(commands, unpack_status, &si);
1615 if (pack_lockfile)
1616 unlink_or_warn(pack_lockfile);
1617 if (report_status)
1618 report(commands, unpack_status);
1619 run_receive_hook(commands, "post-receive", 1);
1620 run_update_post_hook(commands);
1621 if (auto_gc) {
1622 const char *argv_gc_auto[] = {
1623 "gc", "--auto", "--quiet", NULL,
1624 };
1625 int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1626 run_command_v_opt(argv_gc_auto, opt);
1627 }
1628 if (auto_update_server_info)
1629 update_server_info(0);
1630 clear_shallow_info(&si);
1631 }
1632 if (use_sideband)
1633 packet_flush(1);
1634 sha1_array_clear(&shallow);
1635 sha1_array_clear(&ref);
1636 free((void *)push_cert_nonce);
1637 return 0;
1638}