Merge branch 'rs/ref-transaction-1'
[git/git.git] / builtin / receive-pack.c
1 #include "builtin.h"
2 #include "pack.h"
3 #include "refs.h"
4 #include "pkt-line.h"
5 #include "sideband.h"
6 #include "run-command.h"
7 #include "exec_cmd.h"
8 #include "commit.h"
9 #include "object.h"
10 #include "remote.h"
11 #include "connect.h"
12 #include "transport.h"
13 #include "string-list.h"
14 #include "sha1-array.h"
15 #include "connected.h"
16 #include "argv-array.h"
17 #include "version.h"
18
19 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
20
21 enum deny_action {
22 DENY_UNCONFIGURED,
23 DENY_IGNORE,
24 DENY_WARN,
25 DENY_REFUSE
26 };
27
28 static int deny_deletes;
29 static int deny_non_fast_forwards;
30 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
31 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
32 static int receive_fsck_objects = -1;
33 static int transfer_fsck_objects = -1;
34 static int receive_unpack_limit = -1;
35 static int transfer_unpack_limit = -1;
36 static int unpack_limit = 100;
37 static int report_status;
38 static int use_sideband;
39 static int quiet;
40 static int prefer_ofs_delta = 1;
41 static int auto_update_server_info;
42 static int auto_gc = 1;
43 static int fix_thin = 1;
44 static const char *head_name;
45 static void *head_name_to_free;
46 static int sent_capabilities;
47 static int shallow_update;
48 static const char *alt_shallow_file;
49
50 static enum deny_action parse_deny_action(const char *var, const char *value)
51 {
52 if (value) {
53 if (!strcasecmp(value, "ignore"))
54 return DENY_IGNORE;
55 if (!strcasecmp(value, "warn"))
56 return DENY_WARN;
57 if (!strcasecmp(value, "refuse"))
58 return DENY_REFUSE;
59 }
60 if (git_config_bool(var, value))
61 return DENY_REFUSE;
62 return DENY_IGNORE;
63 }
64
65 static int receive_pack_config(const char *var, const char *value, void *cb)
66 {
67 int status = parse_hide_refs_config(var, value, "receive");
68
69 if (status)
70 return status;
71
72 if (strcmp(var, "receive.denydeletes") == 0) {
73 deny_deletes = git_config_bool(var, value);
74 return 0;
75 }
76
77 if (strcmp(var, "receive.denynonfastforwards") == 0) {
78 deny_non_fast_forwards = git_config_bool(var, value);
79 return 0;
80 }
81
82 if (strcmp(var, "receive.unpacklimit") == 0) {
83 receive_unpack_limit = git_config_int(var, value);
84 return 0;
85 }
86
87 if (strcmp(var, "transfer.unpacklimit") == 0) {
88 transfer_unpack_limit = git_config_int(var, value);
89 return 0;
90 }
91
92 if (strcmp(var, "receive.fsckobjects") == 0) {
93 receive_fsck_objects = git_config_bool(var, value);
94 return 0;
95 }
96
97 if (strcmp(var, "transfer.fsckobjects") == 0) {
98 transfer_fsck_objects = git_config_bool(var, value);
99 return 0;
100 }
101
102 if (!strcmp(var, "receive.denycurrentbranch")) {
103 deny_current_branch = parse_deny_action(var, value);
104 return 0;
105 }
106
107 if (strcmp(var, "receive.denydeletecurrent") == 0) {
108 deny_delete_current = parse_deny_action(var, value);
109 return 0;
110 }
111
112 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
113 prefer_ofs_delta = git_config_bool(var, value);
114 return 0;
115 }
116
117 if (strcmp(var, "receive.updateserverinfo") == 0) {
118 auto_update_server_info = git_config_bool(var, value);
119 return 0;
120 }
121
122 if (strcmp(var, "receive.autogc") == 0) {
123 auto_gc = git_config_bool(var, value);
124 return 0;
125 }
126
127 if (strcmp(var, "receive.shallowupdate") == 0) {
128 shallow_update = git_config_bool(var, value);
129 return 0;
130 }
131
132 return git_default_config(var, value, cb);
133 }
134
135 static void show_ref(const char *path, const unsigned char *sha1)
136 {
137 if (ref_is_hidden(path))
138 return;
139
140 if (sent_capabilities)
141 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
142 else
143 packet_write(1, "%s %s%c%s%s agent=%s\n",
144 sha1_to_hex(sha1), path, 0,
145 " report-status delete-refs side-band-64k quiet",
146 prefer_ofs_delta ? " ofs-delta" : "",
147 git_user_agent_sanitized());
148 sent_capabilities = 1;
149 }
150
151 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
152 {
153 path = strip_namespace(path);
154 /*
155 * Advertise refs outside our current namespace as ".have"
156 * refs, so that the client can use them to minimize data
157 * transfer but will otherwise ignore them. This happens to
158 * cover ".have" that are thrown in by add_one_alternate_ref()
159 * to mark histories that are complete in our alternates as
160 * well.
161 */
162 if (!path)
163 path = ".have";
164 show_ref(path, sha1);
165 return 0;
166 }
167
168 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
169 {
170 show_ref(".have", sha1);
171 }
172
173 static void collect_one_alternate_ref(const struct ref *ref, void *data)
174 {
175 struct sha1_array *sa = data;
176 sha1_array_append(sa, ref->old_sha1);
177 }
178
179 static void write_head_info(void)
180 {
181 struct sha1_array sa = SHA1_ARRAY_INIT;
182 for_each_alternate_ref(collect_one_alternate_ref, &sa);
183 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
184 sha1_array_clear(&sa);
185 for_each_ref(show_ref_cb, NULL);
186 if (!sent_capabilities)
187 show_ref("capabilities^{}", null_sha1);
188
189 advertise_shallow_grafts(1);
190
191 /* EOF */
192 packet_flush(1);
193 }
194
195 struct command {
196 struct command *next;
197 const char *error_string;
198 unsigned int skip_update:1,
199 did_not_exist:1;
200 int index;
201 unsigned char old_sha1[20];
202 unsigned char new_sha1[20];
203 char ref_name[FLEX_ARRAY]; /* more */
204 };
205
206 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
207 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
208
209 static void report_message(const char *prefix, const char *err, va_list params)
210 {
211 int sz = strlen(prefix);
212 char msg[4096];
213
214 strncpy(msg, prefix, sz);
215 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
216 if (sz > (sizeof(msg) - 1))
217 sz = sizeof(msg) - 1;
218 msg[sz++] = '\n';
219
220 if (use_sideband)
221 send_sideband(1, 2, msg, sz, use_sideband);
222 else
223 xwrite(2, msg, sz);
224 }
225
226 static void rp_warning(const char *err, ...)
227 {
228 va_list params;
229 va_start(params, err);
230 report_message("warning: ", err, params);
231 va_end(params);
232 }
233
234 static void rp_error(const char *err, ...)
235 {
236 va_list params;
237 va_start(params, err);
238 report_message("error: ", err, params);
239 va_end(params);
240 }
241
242 static int copy_to_sideband(int in, int out, void *arg)
243 {
244 char data[128];
245 while (1) {
246 ssize_t sz = xread(in, data, sizeof(data));
247 if (sz <= 0)
248 break;
249 send_sideband(1, 2, data, sz, use_sideband);
250 }
251 close(in);
252 return 0;
253 }
254
255 typedef int (*feed_fn)(void *, const char **, size_t *);
256 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
257 {
258 struct child_process proc = CHILD_PROCESS_INIT;
259 struct async muxer;
260 const char *argv[2];
261 int code;
262
263 argv[0] = find_hook(hook_name);
264 if (!argv[0])
265 return 0;
266
267 argv[1] = NULL;
268
269 proc.argv = argv;
270 proc.in = -1;
271 proc.stdout_to_stderr = 1;
272
273 if (use_sideband) {
274 memset(&muxer, 0, sizeof(muxer));
275 muxer.proc = copy_to_sideband;
276 muxer.in = -1;
277 code = start_async(&muxer);
278 if (code)
279 return code;
280 proc.err = muxer.in;
281 }
282
283 code = start_command(&proc);
284 if (code) {
285 if (use_sideband)
286 finish_async(&muxer);
287 return code;
288 }
289
290 while (1) {
291 const char *buf;
292 size_t n;
293 if (feed(feed_state, &buf, &n))
294 break;
295 if (write_in_full(proc.in, buf, n) != n)
296 break;
297 }
298 close(proc.in);
299 if (use_sideband)
300 finish_async(&muxer);
301 return finish_command(&proc);
302 }
303
304 struct receive_hook_feed_state {
305 struct command *cmd;
306 int skip_broken;
307 struct strbuf buf;
308 };
309
310 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
311 {
312 struct receive_hook_feed_state *state = state_;
313 struct command *cmd = state->cmd;
314
315 while (cmd &&
316 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
317 cmd = cmd->next;
318 if (!cmd)
319 return -1; /* EOF */
320 strbuf_reset(&state->buf);
321 strbuf_addf(&state->buf, "%s %s %s\n",
322 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
323 cmd->ref_name);
324 state->cmd = cmd->next;
325 if (bufp) {
326 *bufp = state->buf.buf;
327 *sizep = state->buf.len;
328 }
329 return 0;
330 }
331
332 static int run_receive_hook(struct command *commands, const char *hook_name,
333 int skip_broken)
334 {
335 struct receive_hook_feed_state state;
336 int status;
337
338 strbuf_init(&state.buf, 0);
339 state.cmd = commands;
340 state.skip_broken = skip_broken;
341 if (feed_receive_hook(&state, NULL, NULL))
342 return 0;
343 state.cmd = commands;
344 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
345 strbuf_release(&state.buf);
346 return status;
347 }
348
349 static int run_update_hook(struct command *cmd)
350 {
351 const char *argv[5];
352 struct child_process proc = CHILD_PROCESS_INIT;
353 int code;
354
355 argv[0] = find_hook("update");
356 if (!argv[0])
357 return 0;
358
359 argv[1] = cmd->ref_name;
360 argv[2] = sha1_to_hex(cmd->old_sha1);
361 argv[3] = sha1_to_hex(cmd->new_sha1);
362 argv[4] = NULL;
363
364 proc.no_stdin = 1;
365 proc.stdout_to_stderr = 1;
366 proc.err = use_sideband ? -1 : 0;
367 proc.argv = argv;
368
369 code = start_command(&proc);
370 if (code)
371 return code;
372 if (use_sideband)
373 copy_to_sideband(proc.err, -1, NULL);
374 return finish_command(&proc);
375 }
376
377 static int is_ref_checked_out(const char *ref)
378 {
379 if (is_bare_repository())
380 return 0;
381
382 if (!head_name)
383 return 0;
384 return !strcmp(head_name, ref);
385 }
386
387 static char *refuse_unconfigured_deny_msg[] = {
388 "By default, updating the current branch in a non-bare repository",
389 "is denied, because it will make the index and work tree inconsistent",
390 "with what you pushed, and will require 'git reset --hard' to match",
391 "the work tree to HEAD.",
392 "",
393 "You can set 'receive.denyCurrentBranch' configuration variable to",
394 "'ignore' or 'warn' in the remote repository to allow pushing into",
395 "its current branch; however, this is not recommended unless you",
396 "arranged to update its work tree to match what you pushed in some",
397 "other way.",
398 "",
399 "To squelch this message and still keep the default behaviour, set",
400 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
401 };
402
403 static void refuse_unconfigured_deny(void)
404 {
405 int i;
406 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
407 rp_error("%s", refuse_unconfigured_deny_msg[i]);
408 }
409
410 static char *refuse_unconfigured_deny_delete_current_msg[] = {
411 "By default, deleting the current branch is denied, because the next",
412 "'git clone' won't result in any file checked out, causing confusion.",
413 "",
414 "You can set 'receive.denyDeleteCurrent' configuration variable to",
415 "'warn' or 'ignore' in the remote repository to allow deleting the",
416 "current branch, with or without a warning message.",
417 "",
418 "To squelch this message, you can set it to 'refuse'."
419 };
420
421 static void refuse_unconfigured_deny_delete_current(void)
422 {
423 int i;
424 for (i = 0;
425 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
426 i++)
427 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
428 }
429
430 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
431 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
432 {
433 static struct lock_file shallow_lock;
434 struct sha1_array extra = SHA1_ARRAY_INIT;
435 const char *alt_file;
436 uint32_t mask = 1 << (cmd->index % 32);
437 int i;
438
439 trace_printf_key(&trace_shallow,
440 "shallow: update_shallow_ref %s\n", cmd->ref_name);
441 for (i = 0; i < si->shallow->nr; i++)
442 if (si->used_shallow[i] &&
443 (si->used_shallow[i][cmd->index / 32] & mask) &&
444 !delayed_reachability_test(si, i))
445 sha1_array_append(&extra, si->shallow->sha1[i]);
446
447 setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
448 if (check_shallow_connected(command_singleton_iterator,
449 0, cmd, alt_file)) {
450 rollback_lock_file(&shallow_lock);
451 sha1_array_clear(&extra);
452 return -1;
453 }
454
455 commit_lock_file(&shallow_lock);
456
457 /*
458 * Make sure setup_alternate_shallow() for the next ref does
459 * not lose these new roots..
460 */
461 for (i = 0; i < extra.nr; i++)
462 register_shallow(extra.sha1[i]);
463
464 si->shallow_ref[cmd->index] = 0;
465 sha1_array_clear(&extra);
466 return 0;
467 }
468
469 static const char *update(struct command *cmd, struct shallow_info *si)
470 {
471 const char *name = cmd->ref_name;
472 struct strbuf namespaced_name_buf = STRBUF_INIT;
473 const char *namespaced_name;
474 unsigned char *old_sha1 = cmd->old_sha1;
475 unsigned char *new_sha1 = cmd->new_sha1;
476
477 /* only refs/... are allowed */
478 if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
479 rp_error("refusing to create funny ref '%s' remotely", name);
480 return "funny refname";
481 }
482
483 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
484 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
485
486 if (is_ref_checked_out(namespaced_name)) {
487 switch (deny_current_branch) {
488 case DENY_IGNORE:
489 break;
490 case DENY_WARN:
491 rp_warning("updating the current branch");
492 break;
493 case DENY_REFUSE:
494 case DENY_UNCONFIGURED:
495 rp_error("refusing to update checked out branch: %s", name);
496 if (deny_current_branch == DENY_UNCONFIGURED)
497 refuse_unconfigured_deny();
498 return "branch is currently checked out";
499 }
500 }
501
502 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
503 error("unpack should have generated %s, "
504 "but I can't find it!", sha1_to_hex(new_sha1));
505 return "bad pack";
506 }
507
508 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
509 if (deny_deletes && starts_with(name, "refs/heads/")) {
510 rp_error("denying ref deletion for %s", name);
511 return "deletion prohibited";
512 }
513
514 if (!strcmp(namespaced_name, head_name)) {
515 switch (deny_delete_current) {
516 case DENY_IGNORE:
517 break;
518 case DENY_WARN:
519 rp_warning("deleting the current branch");
520 break;
521 case DENY_REFUSE:
522 case DENY_UNCONFIGURED:
523 if (deny_delete_current == DENY_UNCONFIGURED)
524 refuse_unconfigured_deny_delete_current();
525 rp_error("refusing to delete the current branch: %s", name);
526 return "deletion of the current branch prohibited";
527 }
528 }
529 }
530
531 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
532 !is_null_sha1(old_sha1) &&
533 starts_with(name, "refs/heads/")) {
534 struct object *old_object, *new_object;
535 struct commit *old_commit, *new_commit;
536
537 old_object = parse_object(old_sha1);
538 new_object = parse_object(new_sha1);
539
540 if (!old_object || !new_object ||
541 old_object->type != OBJ_COMMIT ||
542 new_object->type != OBJ_COMMIT) {
543 error("bad sha1 objects for %s", name);
544 return "bad ref";
545 }
546 old_commit = (struct commit *)old_object;
547 new_commit = (struct commit *)new_object;
548 if (!in_merge_bases(old_commit, new_commit)) {
549 rp_error("denying non-fast-forward %s"
550 " (you should pull first)", name);
551 return "non-fast-forward";
552 }
553 }
554 if (run_update_hook(cmd)) {
555 rp_error("hook declined to update %s", name);
556 return "hook declined";
557 }
558
559 if (is_null_sha1(new_sha1)) {
560 if (!parse_object(old_sha1)) {
561 old_sha1 = NULL;
562 if (ref_exists(name)) {
563 rp_warning("Allowing deletion of corrupt ref.");
564 } else {
565 rp_warning("Deleting a non-existent ref.");
566 cmd->did_not_exist = 1;
567 }
568 }
569 if (delete_ref(namespaced_name, old_sha1, 0)) {
570 rp_error("failed to delete %s", name);
571 return "failed to delete";
572 }
573 return NULL; /* good */
574 }
575 else {
576 struct strbuf err = STRBUF_INIT;
577 struct ref_transaction *transaction;
578
579 if (shallow_update && si->shallow_ref[cmd->index] &&
580 update_shallow_ref(cmd, si))
581 return "shallow error";
582
583 transaction = ref_transaction_begin(&err);
584 if (!transaction ||
585 ref_transaction_update(transaction, namespaced_name,
586 new_sha1, old_sha1, 0, 1, &err) ||
587 ref_transaction_commit(transaction, "push", &err)) {
588 ref_transaction_free(transaction);
589
590 rp_error("%s", err.buf);
591 strbuf_release(&err);
592 return "failed to update ref";
593 }
594
595 ref_transaction_free(transaction);
596 strbuf_release(&err);
597 return NULL; /* good */
598 }
599 }
600
601 static void run_update_post_hook(struct command *commands)
602 {
603 struct command *cmd;
604 int argc;
605 const char **argv;
606 struct child_process proc = CHILD_PROCESS_INIT;
607 char *hook;
608
609 hook = find_hook("post-update");
610 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
611 if (cmd->error_string || cmd->did_not_exist)
612 continue;
613 argc++;
614 }
615 if (!argc || !hook)
616 return;
617
618 argv = xmalloc(sizeof(*argv) * (2 + argc));
619 argv[0] = hook;
620
621 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
622 if (cmd->error_string || cmd->did_not_exist)
623 continue;
624 argv[argc] = xstrdup(cmd->ref_name);
625 argc++;
626 }
627 argv[argc] = NULL;
628
629 proc.no_stdin = 1;
630 proc.stdout_to_stderr = 1;
631 proc.err = use_sideband ? -1 : 0;
632 proc.argv = argv;
633
634 if (!start_command(&proc)) {
635 if (use_sideband)
636 copy_to_sideband(proc.err, -1, NULL);
637 finish_command(&proc);
638 }
639 }
640
641 static void check_aliased_update(struct command *cmd, struct string_list *list)
642 {
643 struct strbuf buf = STRBUF_INIT;
644 const char *dst_name;
645 struct string_list_item *item;
646 struct command *dst_cmd;
647 unsigned char sha1[20];
648 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
649 int flag;
650
651 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
652 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
653 strbuf_release(&buf);
654
655 if (!(flag & REF_ISSYMREF))
656 return;
657
658 dst_name = strip_namespace(dst_name);
659 if (!dst_name) {
660 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
661 cmd->skip_update = 1;
662 cmd->error_string = "broken symref";
663 return;
664 }
665
666 if ((item = string_list_lookup(list, dst_name)) == NULL)
667 return;
668
669 cmd->skip_update = 1;
670
671 dst_cmd = (struct command *) item->util;
672
673 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
674 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
675 return;
676
677 dst_cmd->skip_update = 1;
678
679 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
680 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
681 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
682 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
683 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
684 " its target '%s' (%s..%s)",
685 cmd->ref_name, cmd_oldh, cmd_newh,
686 dst_cmd->ref_name, dst_oldh, dst_newh);
687
688 cmd->error_string = dst_cmd->error_string =
689 "inconsistent aliased update";
690 }
691
692 static void check_aliased_updates(struct command *commands)
693 {
694 struct command *cmd;
695 struct string_list ref_list = STRING_LIST_INIT_NODUP;
696
697 for (cmd = commands; cmd; cmd = cmd->next) {
698 struct string_list_item *item =
699 string_list_append(&ref_list, cmd->ref_name);
700 item->util = (void *)cmd;
701 }
702 sort_string_list(&ref_list);
703
704 for (cmd = commands; cmd; cmd = cmd->next) {
705 if (!cmd->error_string)
706 check_aliased_update(cmd, &ref_list);
707 }
708
709 string_list_clear(&ref_list, 0);
710 }
711
712 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
713 {
714 struct command **cmd_list = cb_data;
715 struct command *cmd = *cmd_list;
716
717 if (!cmd || is_null_sha1(cmd->new_sha1))
718 return -1; /* end of list */
719 *cmd_list = NULL; /* this returns only one */
720 hashcpy(sha1, cmd->new_sha1);
721 return 0;
722 }
723
724 static void set_connectivity_errors(struct command *commands,
725 struct shallow_info *si)
726 {
727 struct command *cmd;
728
729 for (cmd = commands; cmd; cmd = cmd->next) {
730 struct command *singleton = cmd;
731 if (shallow_update && si->shallow_ref[cmd->index])
732 /* to be checked in update_shallow_ref() */
733 continue;
734 if (!check_everything_connected(command_singleton_iterator,
735 0, &singleton))
736 continue;
737 cmd->error_string = "missing necessary objects";
738 }
739 }
740
741 struct iterate_data {
742 struct command *cmds;
743 struct shallow_info *si;
744 };
745
746 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
747 {
748 struct iterate_data *data = cb_data;
749 struct command **cmd_list = &data->cmds;
750 struct command *cmd = *cmd_list;
751
752 for (; cmd; cmd = cmd->next) {
753 if (shallow_update && data->si->shallow_ref[cmd->index])
754 /* to be checked in update_shallow_ref() */
755 continue;
756 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
757 hashcpy(sha1, cmd->new_sha1);
758 *cmd_list = cmd->next;
759 return 0;
760 }
761 }
762 *cmd_list = NULL;
763 return -1; /* end of list */
764 }
765
766 static void reject_updates_to_hidden(struct command *commands)
767 {
768 struct command *cmd;
769
770 for (cmd = commands; cmd; cmd = cmd->next) {
771 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
772 continue;
773 if (is_null_sha1(cmd->new_sha1))
774 cmd->error_string = "deny deleting a hidden ref";
775 else
776 cmd->error_string = "deny updating a hidden ref";
777 }
778 }
779
780 static void execute_commands(struct command *commands,
781 const char *unpacker_error,
782 struct shallow_info *si)
783 {
784 int checked_connectivity;
785 struct command *cmd;
786 unsigned char sha1[20];
787 struct iterate_data data;
788
789 if (unpacker_error) {
790 for (cmd = commands; cmd; cmd = cmd->next)
791 cmd->error_string = "unpacker error";
792 return;
793 }
794
795 data.cmds = commands;
796 data.si = si;
797 if (check_everything_connected(iterate_receive_command_list, 0, &data))
798 set_connectivity_errors(commands, si);
799
800 reject_updates_to_hidden(commands);
801
802 if (run_receive_hook(commands, "pre-receive", 0)) {
803 for (cmd = commands; cmd; cmd = cmd->next) {
804 if (!cmd->error_string)
805 cmd->error_string = "pre-receive hook declined";
806 }
807 return;
808 }
809
810 check_aliased_updates(commands);
811
812 free(head_name_to_free);
813 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
814
815 checked_connectivity = 1;
816 for (cmd = commands; cmd; cmd = cmd->next) {
817 if (cmd->error_string)
818 continue;
819
820 if (cmd->skip_update)
821 continue;
822
823 cmd->error_string = update(cmd, si);
824 if (shallow_update && !cmd->error_string &&
825 si->shallow_ref[cmd->index]) {
826 error("BUG: connectivity check has not been run on ref %s",
827 cmd->ref_name);
828 checked_connectivity = 0;
829 }
830 }
831
832 if (shallow_update && !checked_connectivity)
833 error("BUG: run 'git fsck' for safety.\n"
834 "If there are errors, try to remove "
835 "the reported refs above");
836 }
837
838 static struct command *read_head_info(struct sha1_array *shallow)
839 {
840 struct command *commands = NULL;
841 struct command **p = &commands;
842 for (;;) {
843 char *line;
844 unsigned char old_sha1[20], new_sha1[20];
845 struct command *cmd;
846 char *refname;
847 int len, reflen;
848
849 line = packet_read_line(0, &len);
850 if (!line)
851 break;
852
853 if (len == 48 && starts_with(line, "shallow ")) {
854 if (get_sha1_hex(line + 8, old_sha1))
855 die("protocol error: expected shallow sha, got '%s'", line + 8);
856 sha1_array_append(shallow, old_sha1);
857 continue;
858 }
859
860 if (len < 83 ||
861 line[40] != ' ' ||
862 line[81] != ' ' ||
863 get_sha1_hex(line, old_sha1) ||
864 get_sha1_hex(line + 41, new_sha1))
865 die("protocol error: expected old/new/ref, got '%s'",
866 line);
867
868 refname = line + 82;
869 reflen = strlen(refname);
870 if (reflen + 82 < len) {
871 const char *feature_list = refname + reflen + 1;
872 if (parse_feature_request(feature_list, "report-status"))
873 report_status = 1;
874 if (parse_feature_request(feature_list, "side-band-64k"))
875 use_sideband = LARGE_PACKET_MAX;
876 if (parse_feature_request(feature_list, "quiet"))
877 quiet = 1;
878 }
879 cmd = xcalloc(1, sizeof(struct command) + len - 80);
880 hashcpy(cmd->old_sha1, old_sha1);
881 hashcpy(cmd->new_sha1, new_sha1);
882 memcpy(cmd->ref_name, line + 82, len - 81);
883 *p = cmd;
884 p = &cmd->next;
885 }
886 return commands;
887 }
888
889 static const char *parse_pack_header(struct pack_header *hdr)
890 {
891 switch (read_pack_header(0, hdr)) {
892 case PH_ERROR_EOF:
893 return "eof before pack header was fully read";
894
895 case PH_ERROR_PACK_SIGNATURE:
896 return "protocol error (pack signature mismatch detected)";
897
898 case PH_ERROR_PROTOCOL:
899 return "protocol error (pack version unsupported)";
900
901 default:
902 return "unknown error in parse_pack_header";
903
904 case 0:
905 return NULL;
906 }
907 }
908
909 static const char *pack_lockfile;
910
911 static const char *unpack(int err_fd, struct shallow_info *si)
912 {
913 struct pack_header hdr;
914 struct argv_array av = ARGV_ARRAY_INIT;
915 const char *hdr_err;
916 int status;
917 char hdr_arg[38];
918 struct child_process child = CHILD_PROCESS_INIT;
919 int fsck_objects = (receive_fsck_objects >= 0
920 ? receive_fsck_objects
921 : transfer_fsck_objects >= 0
922 ? transfer_fsck_objects
923 : 0);
924
925 hdr_err = parse_pack_header(&hdr);
926 if (hdr_err) {
927 if (err_fd > 0)
928 close(err_fd);
929 return hdr_err;
930 }
931 snprintf(hdr_arg, sizeof(hdr_arg),
932 "--pack_header=%"PRIu32",%"PRIu32,
933 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
934
935 if (si->nr_ours || si->nr_theirs) {
936 alt_shallow_file = setup_temporary_shallow(si->shallow);
937 argv_array_pushl(&av, "--shallow-file", alt_shallow_file, NULL);
938 }
939
940 if (ntohl(hdr.hdr_entries) < unpack_limit) {
941 argv_array_pushl(&av, "unpack-objects", hdr_arg, NULL);
942 if (quiet)
943 argv_array_push(&av, "-q");
944 if (fsck_objects)
945 argv_array_push(&av, "--strict");
946 child.argv = av.argv;
947 child.no_stdout = 1;
948 child.err = err_fd;
949 child.git_cmd = 1;
950 status = run_command(&child);
951 if (status)
952 return "unpack-objects abnormal exit";
953 } else {
954 int s;
955 char keep_arg[256];
956
957 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
958 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
959 strcpy(keep_arg + s, "localhost");
960
961 argv_array_pushl(&av, "index-pack",
962 "--stdin", hdr_arg, keep_arg, NULL);
963 if (fsck_objects)
964 argv_array_push(&av, "--strict");
965 if (fix_thin)
966 argv_array_push(&av, "--fix-thin");
967 child.argv = av.argv;
968 child.out = -1;
969 child.err = err_fd;
970 child.git_cmd = 1;
971 status = start_command(&child);
972 if (status)
973 return "index-pack fork failed";
974 pack_lockfile = index_pack_lockfile(child.out);
975 close(child.out);
976 status = finish_command(&child);
977 if (status)
978 return "index-pack abnormal exit";
979 reprepare_packed_git();
980 }
981 return NULL;
982 }
983
984 static const char *unpack_with_sideband(struct shallow_info *si)
985 {
986 struct async muxer;
987 const char *ret;
988
989 if (!use_sideband)
990 return unpack(0, si);
991
992 memset(&muxer, 0, sizeof(muxer));
993 muxer.proc = copy_to_sideband;
994 muxer.in = -1;
995 if (start_async(&muxer))
996 return NULL;
997
998 ret = unpack(muxer.in, si);
999
1000 finish_async(&muxer);
1001 return ret;
1002 }
1003
1004 static void prepare_shallow_update(struct command *commands,
1005 struct shallow_info *si)
1006 {
1007 int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1008
1009 si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1010 si->shallow->nr);
1011 assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1012
1013 si->need_reachability_test =
1014 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1015 si->reachable =
1016 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1017 si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1018
1019 for (i = 0; i < si->nr_ours; i++)
1020 si->need_reachability_test[si->ours[i]] = 1;
1021
1022 for (i = 0; i < si->shallow->nr; i++) {
1023 if (!si->used_shallow[i])
1024 continue;
1025 for (j = 0; j < bitmap_size; j++) {
1026 if (!si->used_shallow[i][j])
1027 continue;
1028 si->need_reachability_test[i]++;
1029 for (k = 0; k < 32; k++)
1030 if (si->used_shallow[i][j] & (1 << k))
1031 si->shallow_ref[j * 32 + k]++;
1032 }
1033
1034 /*
1035 * true for those associated with some refs and belong
1036 * in "ours" list aka "step 7 not done yet"
1037 */
1038 si->need_reachability_test[i] =
1039 si->need_reachability_test[i] > 1;
1040 }
1041
1042 /*
1043 * keep hooks happy by forcing a temporary shallow file via
1044 * env variable because we can't add --shallow-file to every
1045 * command. check_everything_connected() will be done with
1046 * true .git/shallow though.
1047 */
1048 setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1049 }
1050
1051 static void update_shallow_info(struct command *commands,
1052 struct shallow_info *si,
1053 struct sha1_array *ref)
1054 {
1055 struct command *cmd;
1056 int *ref_status;
1057 remove_nonexistent_theirs_shallow(si);
1058 if (!si->nr_ours && !si->nr_theirs) {
1059 shallow_update = 0;
1060 return;
1061 }
1062
1063 for (cmd = commands; cmd; cmd = cmd->next) {
1064 if (is_null_sha1(cmd->new_sha1))
1065 continue;
1066 sha1_array_append(ref, cmd->new_sha1);
1067 cmd->index = ref->nr - 1;
1068 }
1069 si->ref = ref;
1070
1071 if (shallow_update) {
1072 prepare_shallow_update(commands, si);
1073 return;
1074 }
1075
1076 ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1077 assign_shallow_commits_to_refs(si, NULL, ref_status);
1078 for (cmd = commands; cmd; cmd = cmd->next) {
1079 if (is_null_sha1(cmd->new_sha1))
1080 continue;
1081 if (ref_status[cmd->index]) {
1082 cmd->error_string = "shallow update not allowed";
1083 cmd->skip_update = 1;
1084 }
1085 }
1086 free(ref_status);
1087 }
1088
1089 static void report(struct command *commands, const char *unpack_status)
1090 {
1091 struct command *cmd;
1092 struct strbuf buf = STRBUF_INIT;
1093
1094 packet_buf_write(&buf, "unpack %s\n",
1095 unpack_status ? unpack_status : "ok");
1096 for (cmd = commands; cmd; cmd = cmd->next) {
1097 if (!cmd->error_string)
1098 packet_buf_write(&buf, "ok %s\n",
1099 cmd->ref_name);
1100 else
1101 packet_buf_write(&buf, "ng %s %s\n",
1102 cmd->ref_name, cmd->error_string);
1103 }
1104 packet_buf_flush(&buf);
1105
1106 if (use_sideband)
1107 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1108 else
1109 write_or_die(1, buf.buf, buf.len);
1110 strbuf_release(&buf);
1111 }
1112
1113 static int delete_only(struct command *commands)
1114 {
1115 struct command *cmd;
1116 for (cmd = commands; cmd; cmd = cmd->next) {
1117 if (!is_null_sha1(cmd->new_sha1))
1118 return 0;
1119 }
1120 return 1;
1121 }
1122
1123 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1124 {
1125 int advertise_refs = 0;
1126 int stateless_rpc = 0;
1127 int i;
1128 const char *dir = NULL;
1129 struct command *commands;
1130 struct sha1_array shallow = SHA1_ARRAY_INIT;
1131 struct sha1_array ref = SHA1_ARRAY_INIT;
1132 struct shallow_info si;
1133
1134 packet_trace_identity("receive-pack");
1135
1136 argv++;
1137 for (i = 1; i < argc; i++) {
1138 const char *arg = *argv++;
1139
1140 if (*arg == '-') {
1141 if (!strcmp(arg, "--quiet")) {
1142 quiet = 1;
1143 continue;
1144 }
1145
1146 if (!strcmp(arg, "--advertise-refs")) {
1147 advertise_refs = 1;
1148 continue;
1149 }
1150 if (!strcmp(arg, "--stateless-rpc")) {
1151 stateless_rpc = 1;
1152 continue;
1153 }
1154 if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1155 fix_thin = 0;
1156 continue;
1157 }
1158
1159 usage(receive_pack_usage);
1160 }
1161 if (dir)
1162 usage(receive_pack_usage);
1163 dir = arg;
1164 }
1165 if (!dir)
1166 usage(receive_pack_usage);
1167
1168 setup_path();
1169
1170 if (!enter_repo(dir, 0))
1171 die("'%s' does not appear to be a git repository", dir);
1172
1173 git_config(receive_pack_config, NULL);
1174
1175 if (0 <= transfer_unpack_limit)
1176 unpack_limit = transfer_unpack_limit;
1177 else if (0 <= receive_unpack_limit)
1178 unpack_limit = receive_unpack_limit;
1179
1180 if (advertise_refs || !stateless_rpc) {
1181 write_head_info();
1182 }
1183 if (advertise_refs)
1184 return 0;
1185
1186 if ((commands = read_head_info(&shallow)) != NULL) {
1187 const char *unpack_status = NULL;
1188
1189 prepare_shallow_info(&si, &shallow);
1190 if (!si.nr_ours && !si.nr_theirs)
1191 shallow_update = 0;
1192 if (!delete_only(commands)) {
1193 unpack_status = unpack_with_sideband(&si);
1194 update_shallow_info(commands, &si, &ref);
1195 }
1196 execute_commands(commands, unpack_status, &si);
1197 if (pack_lockfile)
1198 unlink_or_warn(pack_lockfile);
1199 if (report_status)
1200 report(commands, unpack_status);
1201 run_receive_hook(commands, "post-receive", 1);
1202 run_update_post_hook(commands);
1203 if (auto_gc) {
1204 const char *argv_gc_auto[] = {
1205 "gc", "--auto", "--quiet", NULL,
1206 };
1207 int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1208 run_command_v_opt(argv_gc_auto, opt);
1209 }
1210 if (auto_update_server_info)
1211 update_server_info(0);
1212 clear_shallow_info(&si);
1213 }
1214 if (use_sideband)
1215 packet_flush(1);
1216 sha1_array_clear(&shallow);
1217 sha1_array_clear(&ref);
1218 return 0;
1219 }