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