]> git.ipfire.org Git - thirdparty/git.git/blob - builtin-receive-pack.c
Merge branch 'jh/maint-config-file-prefix'
[thirdparty/git.git] / builtin-receive-pack.c
1 #include "cache.h"
2 #include "pack.h"
3 #include "refs.h"
4 #include "pkt-line.h"
5 #include "run-command.h"
6 #include "exec_cmd.h"
7 #include "commit.h"
8 #include "object.h"
9 #include "remote.h"
10 #include "transport.h"
11
12 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
13
14 enum deny_action {
15 DENY_UNCONFIGURED,
16 DENY_IGNORE,
17 DENY_WARN,
18 DENY_REFUSE,
19 };
20
21 static int deny_deletes;
22 static int deny_non_fast_forwards;
23 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
24 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
25 static int receive_fsck_objects;
26 static int receive_unpack_limit = -1;
27 static int transfer_unpack_limit = -1;
28 static int unpack_limit = 100;
29 static int report_status;
30 static int prefer_ofs_delta = 1;
31 static int auto_update_server_info;
32 static int auto_gc = 1;
33 static const char *head_name;
34 static char *capabilities_to_send;
35
36 static enum deny_action parse_deny_action(const char *var, const char *value)
37 {
38 if (value) {
39 if (!strcasecmp(value, "ignore"))
40 return DENY_IGNORE;
41 if (!strcasecmp(value, "warn"))
42 return DENY_WARN;
43 if (!strcasecmp(value, "refuse"))
44 return DENY_REFUSE;
45 }
46 if (git_config_bool(var, value))
47 return DENY_REFUSE;
48 return DENY_IGNORE;
49 }
50
51 static int receive_pack_config(const char *var, const char *value, void *cb)
52 {
53 if (strcmp(var, "receive.denydeletes") == 0) {
54 deny_deletes = git_config_bool(var, value);
55 return 0;
56 }
57
58 if (strcmp(var, "receive.denynonfastforwards") == 0) {
59 deny_non_fast_forwards = git_config_bool(var, value);
60 return 0;
61 }
62
63 if (strcmp(var, "receive.unpacklimit") == 0) {
64 receive_unpack_limit = git_config_int(var, value);
65 return 0;
66 }
67
68 if (strcmp(var, "transfer.unpacklimit") == 0) {
69 transfer_unpack_limit = git_config_int(var, value);
70 return 0;
71 }
72
73 if (strcmp(var, "receive.fsckobjects") == 0) {
74 receive_fsck_objects = git_config_bool(var, value);
75 return 0;
76 }
77
78 if (!strcmp(var, "receive.denycurrentbranch")) {
79 deny_current_branch = parse_deny_action(var, value);
80 return 0;
81 }
82
83 if (strcmp(var, "receive.denydeletecurrent") == 0) {
84 deny_delete_current = parse_deny_action(var, value);
85 return 0;
86 }
87
88 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
89 prefer_ofs_delta = git_config_bool(var, value);
90 return 0;
91 }
92
93 if (strcmp(var, "receive.updateserverinfo") == 0) {
94 auto_update_server_info = git_config_bool(var, value);
95 return 0;
96 }
97
98 if (strcmp(var, "receive.autogc") == 0) {
99 auto_gc = git_config_bool(var, value);
100 return 0;
101 }
102
103 return git_default_config(var, value, cb);
104 }
105
106 static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
107 {
108 if (!capabilities_to_send)
109 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
110 else
111 packet_write(1, "%s %s%c%s\n",
112 sha1_to_hex(sha1), path, 0, capabilities_to_send);
113 capabilities_to_send = NULL;
114 return 0;
115 }
116
117 static void write_head_info(void)
118 {
119 for_each_ref(show_ref, NULL);
120 if (capabilities_to_send)
121 show_ref("capabilities^{}", null_sha1, 0, NULL);
122
123 }
124
125 struct command {
126 struct command *next;
127 const char *error_string;
128 unsigned char old_sha1[20];
129 unsigned char new_sha1[20];
130 char ref_name[FLEX_ARRAY]; /* more */
131 };
132
133 static struct command *commands;
134
135 static const char pre_receive_hook[] = "hooks/pre-receive";
136 static const char post_receive_hook[] = "hooks/post-receive";
137
138 static int run_receive_hook(const char *hook_name)
139 {
140 static char buf[sizeof(commands->old_sha1) * 2 + PATH_MAX + 4];
141 struct command *cmd;
142 struct child_process proc;
143 const char *argv[2];
144 int have_input = 0, code;
145
146 for (cmd = commands; !have_input && cmd; cmd = cmd->next) {
147 if (!cmd->error_string)
148 have_input = 1;
149 }
150
151 if (!have_input || access(hook_name, X_OK) < 0)
152 return 0;
153
154 argv[0] = hook_name;
155 argv[1] = NULL;
156
157 memset(&proc, 0, sizeof(proc));
158 proc.argv = argv;
159 proc.in = -1;
160 proc.stdout_to_stderr = 1;
161
162 code = start_command(&proc);
163 if (code)
164 return code;
165 for (cmd = commands; cmd; cmd = cmd->next) {
166 if (!cmd->error_string) {
167 size_t n = snprintf(buf, sizeof(buf), "%s %s %s\n",
168 sha1_to_hex(cmd->old_sha1),
169 sha1_to_hex(cmd->new_sha1),
170 cmd->ref_name);
171 if (write_in_full(proc.in, buf, n) != n)
172 break;
173 }
174 }
175 close(proc.in);
176 return finish_command(&proc);
177 }
178
179 static int run_update_hook(struct command *cmd)
180 {
181 static const char update_hook[] = "hooks/update";
182 const char *argv[5];
183
184 if (access(update_hook, X_OK) < 0)
185 return 0;
186
187 argv[0] = update_hook;
188 argv[1] = cmd->ref_name;
189 argv[2] = sha1_to_hex(cmd->old_sha1);
190 argv[3] = sha1_to_hex(cmd->new_sha1);
191 argv[4] = NULL;
192
193 return run_command_v_opt(argv, RUN_COMMAND_NO_STDIN |
194 RUN_COMMAND_STDOUT_TO_STDERR);
195 }
196
197 static int is_ref_checked_out(const char *ref)
198 {
199 if (is_bare_repository())
200 return 0;
201
202 if (!head_name)
203 return 0;
204 return !strcmp(head_name, ref);
205 }
206
207 static char *refuse_unconfigured_deny_msg[] = {
208 "By default, updating the current branch in a non-bare repository",
209 "is denied, because it will make the index and work tree inconsistent",
210 "with what you pushed, and will require 'git reset --hard' to match",
211 "the work tree to HEAD.",
212 "",
213 "You can set 'receive.denyCurrentBranch' configuration variable to",
214 "'ignore' or 'warn' in the remote repository to allow pushing into",
215 "its current branch; however, this is not recommended unless you",
216 "arranged to update its work tree to match what you pushed in some",
217 "other way.",
218 "",
219 "To squelch this message and still keep the default behaviour, set",
220 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
221 };
222
223 static void refuse_unconfigured_deny(void)
224 {
225 int i;
226 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
227 error("%s", refuse_unconfigured_deny_msg[i]);
228 }
229
230 static char *refuse_unconfigured_deny_delete_current_msg[] = {
231 "By default, deleting the current branch is denied, because the next",
232 "'git clone' won't result in any file checked out, causing confusion.",
233 "",
234 "You can set 'receive.denyDeleteCurrent' configuration variable to",
235 "'warn' or 'ignore' in the remote repository to allow deleting the",
236 "current branch, with or without a warning message.",
237 "",
238 "To squelch this message, you can set it to 'refuse'."
239 };
240
241 static void refuse_unconfigured_deny_delete_current(void)
242 {
243 int i;
244 for (i = 0;
245 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
246 i++)
247 error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
248 }
249
250 static const char *update(struct command *cmd)
251 {
252 const char *name = cmd->ref_name;
253 unsigned char *old_sha1 = cmd->old_sha1;
254 unsigned char *new_sha1 = cmd->new_sha1;
255 struct ref_lock *lock;
256
257 /* only refs/... are allowed */
258 if (prefixcmp(name, "refs/") || check_ref_format(name + 5)) {
259 error("refusing to create funny ref '%s' remotely", name);
260 return "funny refname";
261 }
262
263 if (is_ref_checked_out(name)) {
264 switch (deny_current_branch) {
265 case DENY_IGNORE:
266 break;
267 case DENY_WARN:
268 warning("updating the current branch");
269 break;
270 case DENY_REFUSE:
271 case DENY_UNCONFIGURED:
272 error("refusing to update checked out branch: %s", name);
273 if (deny_current_branch == DENY_UNCONFIGURED)
274 refuse_unconfigured_deny();
275 return "branch is currently checked out";
276 }
277 }
278
279 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
280 error("unpack should have generated %s, "
281 "but I can't find it!", sha1_to_hex(new_sha1));
282 return "bad pack";
283 }
284
285 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
286 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
287 error("denying ref deletion for %s", name);
288 return "deletion prohibited";
289 }
290
291 if (!strcmp(name, head_name)) {
292 switch (deny_delete_current) {
293 case DENY_IGNORE:
294 break;
295 case DENY_WARN:
296 warning("deleting the current branch");
297 break;
298 case DENY_REFUSE:
299 case DENY_UNCONFIGURED:
300 if (deny_delete_current == DENY_UNCONFIGURED)
301 refuse_unconfigured_deny_delete_current();
302 error("refusing to delete the current branch: %s", name);
303 return "deletion of the current branch prohibited";
304 }
305 }
306 }
307
308 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
309 !is_null_sha1(old_sha1) &&
310 !prefixcmp(name, "refs/heads/")) {
311 struct object *old_object, *new_object;
312 struct commit *old_commit, *new_commit;
313 struct commit_list *bases, *ent;
314
315 old_object = parse_object(old_sha1);
316 new_object = parse_object(new_sha1);
317
318 if (!old_object || !new_object ||
319 old_object->type != OBJ_COMMIT ||
320 new_object->type != OBJ_COMMIT) {
321 error("bad sha1 objects for %s", name);
322 return "bad ref";
323 }
324 old_commit = (struct commit *)old_object;
325 new_commit = (struct commit *)new_object;
326 bases = get_merge_bases(old_commit, new_commit, 1);
327 for (ent = bases; ent; ent = ent->next)
328 if (!hashcmp(old_sha1, ent->item->object.sha1))
329 break;
330 free_commit_list(bases);
331 if (!ent) {
332 error("denying non-fast-forward %s"
333 " (you should pull first)", name);
334 return "non-fast-forward";
335 }
336 }
337 if (run_update_hook(cmd)) {
338 error("hook declined to update %s", name);
339 return "hook declined";
340 }
341
342 if (is_null_sha1(new_sha1)) {
343 if (!parse_object(old_sha1)) {
344 warning ("Allowing deletion of corrupt ref.");
345 old_sha1 = NULL;
346 }
347 if (delete_ref(name, old_sha1, 0)) {
348 error("failed to delete %s", name);
349 return "failed to delete";
350 }
351 return NULL; /* good */
352 }
353 else {
354 lock = lock_any_ref_for_update(name, old_sha1, 0);
355 if (!lock) {
356 error("failed to lock %s", name);
357 return "failed to lock";
358 }
359 if (write_ref_sha1(lock, new_sha1, "push")) {
360 return "failed to write"; /* error() already called */
361 }
362 return NULL; /* good */
363 }
364 }
365
366 static char update_post_hook[] = "hooks/post-update";
367
368 static void run_update_post_hook(struct command *cmd)
369 {
370 struct command *cmd_p;
371 int argc, status;
372 const char **argv;
373
374 for (argc = 0, cmd_p = cmd; cmd_p; cmd_p = cmd_p->next) {
375 if (cmd_p->error_string)
376 continue;
377 argc++;
378 }
379 if (!argc || access(update_post_hook, X_OK) < 0)
380 return;
381 argv = xmalloc(sizeof(*argv) * (2 + argc));
382 argv[0] = update_post_hook;
383
384 for (argc = 1, cmd_p = cmd; cmd_p; cmd_p = cmd_p->next) {
385 char *p;
386 if (cmd_p->error_string)
387 continue;
388 p = xmalloc(strlen(cmd_p->ref_name) + 1);
389 strcpy(p, cmd_p->ref_name);
390 argv[argc] = p;
391 argc++;
392 }
393 argv[argc] = NULL;
394 status = run_command_v_opt(argv, RUN_COMMAND_NO_STDIN
395 | RUN_COMMAND_STDOUT_TO_STDERR);
396 }
397
398 static void execute_commands(const char *unpacker_error)
399 {
400 struct command *cmd = commands;
401 unsigned char sha1[20];
402
403 if (unpacker_error) {
404 while (cmd) {
405 cmd->error_string = "n/a (unpacker error)";
406 cmd = cmd->next;
407 }
408 return;
409 }
410
411 if (run_receive_hook(pre_receive_hook)) {
412 while (cmd) {
413 cmd->error_string = "pre-receive hook declined";
414 cmd = cmd->next;
415 }
416 return;
417 }
418
419 head_name = resolve_ref("HEAD", sha1, 0, NULL);
420
421 while (cmd) {
422 cmd->error_string = update(cmd);
423 cmd = cmd->next;
424 }
425 }
426
427 static void read_head_info(void)
428 {
429 struct command **p = &commands;
430 for (;;) {
431 static char line[1000];
432 unsigned char old_sha1[20], new_sha1[20];
433 struct command *cmd;
434 char *refname;
435 int len, reflen;
436
437 len = packet_read_line(0, line, sizeof(line));
438 if (!len)
439 break;
440 if (line[len-1] == '\n')
441 line[--len] = 0;
442 if (len < 83 ||
443 line[40] != ' ' ||
444 line[81] != ' ' ||
445 get_sha1_hex(line, old_sha1) ||
446 get_sha1_hex(line + 41, new_sha1))
447 die("protocol error: expected old/new/ref, got '%s'",
448 line);
449
450 refname = line + 82;
451 reflen = strlen(refname);
452 if (reflen + 82 < len) {
453 if (strstr(refname + reflen + 1, "report-status"))
454 report_status = 1;
455 }
456 cmd = xmalloc(sizeof(struct command) + len - 80);
457 hashcpy(cmd->old_sha1, old_sha1);
458 hashcpy(cmd->new_sha1, new_sha1);
459 memcpy(cmd->ref_name, line + 82, len - 81);
460 cmd->error_string = NULL;
461 cmd->next = NULL;
462 *p = cmd;
463 p = &cmd->next;
464 }
465 }
466
467 static const char *parse_pack_header(struct pack_header *hdr)
468 {
469 switch (read_pack_header(0, hdr)) {
470 case PH_ERROR_EOF:
471 return "eof before pack header was fully read";
472
473 case PH_ERROR_PACK_SIGNATURE:
474 return "protocol error (pack signature mismatch detected)";
475
476 case PH_ERROR_PROTOCOL:
477 return "protocol error (pack version unsupported)";
478
479 default:
480 return "unknown error in parse_pack_header";
481
482 case 0:
483 return NULL;
484 }
485 }
486
487 static const char *pack_lockfile;
488
489 static const char *unpack(void)
490 {
491 struct pack_header hdr;
492 const char *hdr_err;
493 char hdr_arg[38];
494
495 hdr_err = parse_pack_header(&hdr);
496 if (hdr_err)
497 return hdr_err;
498 snprintf(hdr_arg, sizeof(hdr_arg),
499 "--pack_header=%"PRIu32",%"PRIu32,
500 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
501
502 if (ntohl(hdr.hdr_entries) < unpack_limit) {
503 int code, i = 0;
504 const char *unpacker[4];
505 unpacker[i++] = "unpack-objects";
506 if (receive_fsck_objects)
507 unpacker[i++] = "--strict";
508 unpacker[i++] = hdr_arg;
509 unpacker[i++] = NULL;
510 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
511 if (!code)
512 return NULL;
513 return "unpack-objects abnormal exit";
514 } else {
515 const char *keeper[7];
516 int s, status, i = 0;
517 char keep_arg[256];
518 struct child_process ip;
519
520 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
521 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
522 strcpy(keep_arg + s, "localhost");
523
524 keeper[i++] = "index-pack";
525 keeper[i++] = "--stdin";
526 if (receive_fsck_objects)
527 keeper[i++] = "--strict";
528 keeper[i++] = "--fix-thin";
529 keeper[i++] = hdr_arg;
530 keeper[i++] = keep_arg;
531 keeper[i++] = NULL;
532 memset(&ip, 0, sizeof(ip));
533 ip.argv = keeper;
534 ip.out = -1;
535 ip.git_cmd = 1;
536 status = start_command(&ip);
537 if (status) {
538 return "index-pack fork failed";
539 }
540 pack_lockfile = index_pack_lockfile(ip.out);
541 close(ip.out);
542 status = finish_command(&ip);
543 if (!status) {
544 reprepare_packed_git();
545 return NULL;
546 }
547 return "index-pack abnormal exit";
548 }
549 }
550
551 static void report(const char *unpack_status)
552 {
553 struct command *cmd;
554 packet_write(1, "unpack %s\n",
555 unpack_status ? unpack_status : "ok");
556 for (cmd = commands; cmd; cmd = cmd->next) {
557 if (!cmd->error_string)
558 packet_write(1, "ok %s\n",
559 cmd->ref_name);
560 else
561 packet_write(1, "ng %s %s\n",
562 cmd->ref_name, cmd->error_string);
563 }
564 packet_flush(1);
565 }
566
567 static int delete_only(struct command *cmd)
568 {
569 while (cmd) {
570 if (!is_null_sha1(cmd->new_sha1))
571 return 0;
572 cmd = cmd->next;
573 }
574 return 1;
575 }
576
577 static int add_refs_from_alternate(struct alternate_object_database *e, void *unused)
578 {
579 char *other;
580 size_t len;
581 struct remote *remote;
582 struct transport *transport;
583 const struct ref *extra;
584
585 e->name[-1] = '\0';
586 other = xstrdup(make_absolute_path(e->base));
587 e->name[-1] = '/';
588 len = strlen(other);
589
590 while (other[len-1] == '/')
591 other[--len] = '\0';
592 if (len < 8 || memcmp(other + len - 8, "/objects", 8))
593 return 0;
594 /* Is this a git repository with refs? */
595 memcpy(other + len - 8, "/refs", 6);
596 if (!is_directory(other))
597 return 0;
598 other[len - 8] = '\0';
599 remote = remote_get(other);
600 transport = transport_get(remote, other);
601 for (extra = transport_get_remote_refs(transport);
602 extra;
603 extra = extra->next) {
604 add_extra_ref(".have", extra->old_sha1, 0);
605 }
606 transport_disconnect(transport);
607 free(other);
608 return 0;
609 }
610
611 static void add_alternate_refs(void)
612 {
613 foreach_alt_odb(add_refs_from_alternate, NULL);
614 }
615
616 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
617 {
618 int advertise_refs = 0;
619 int stateless_rpc = 0;
620 int i;
621 char *dir = NULL;
622
623 argv++;
624 for (i = 1; i < argc; i++) {
625 const char *arg = *argv++;
626
627 if (*arg == '-') {
628 if (!strcmp(arg, "--advertise-refs")) {
629 advertise_refs = 1;
630 continue;
631 }
632 if (!strcmp(arg, "--stateless-rpc")) {
633 stateless_rpc = 1;
634 continue;
635 }
636
637 usage(receive_pack_usage);
638 }
639 if (dir)
640 usage(receive_pack_usage);
641 dir = xstrdup(arg);
642 }
643 if (!dir)
644 usage(receive_pack_usage);
645
646 setup_path();
647
648 if (!enter_repo(dir, 0))
649 die("'%s' does not appear to be a git repository", dir);
650
651 if (is_repository_shallow())
652 die("attempt to push into a shallow repository");
653
654 git_config(receive_pack_config, NULL);
655
656 if (0 <= transfer_unpack_limit)
657 unpack_limit = transfer_unpack_limit;
658 else if (0 <= receive_unpack_limit)
659 unpack_limit = receive_unpack_limit;
660
661 capabilities_to_send = (prefer_ofs_delta) ?
662 " report-status delete-refs ofs-delta " :
663 " report-status delete-refs ";
664
665 if (advertise_refs || !stateless_rpc) {
666 add_alternate_refs();
667 write_head_info();
668 clear_extra_refs();
669
670 /* EOF */
671 packet_flush(1);
672 }
673 if (advertise_refs)
674 return 0;
675
676 read_head_info();
677 if (commands) {
678 const char *unpack_status = NULL;
679
680 if (!delete_only(commands))
681 unpack_status = unpack();
682 execute_commands(unpack_status);
683 if (pack_lockfile)
684 unlink_or_warn(pack_lockfile);
685 if (report_status)
686 report(unpack_status);
687 run_receive_hook(post_receive_hook);
688 run_update_post_hook(commands);
689 if (auto_gc) {
690 const char *argv_gc_auto[] = {
691 "gc", "--auto", "--quiet", NULL,
692 };
693 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
694 }
695 if (auto_update_server_info)
696 update_server_info(0);
697 }
698 return 0;
699 }