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