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 "transport.h"
12#include "string-list.h"
13#include "sha1-array.h"
14#include "connected.h"
15
16static const char receive_pack_usage[] = "git receive-pack <git-dir>";
17
18enum deny_action {
19 DENY_UNCONFIGURED,
20 DENY_IGNORE,
21 DENY_WARN,
22 DENY_REFUSE
23};
24
25static int deny_deletes;
26static int deny_non_fast_forwards;
27static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
28static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
29static int receive_fsck_objects = -1;
30static int transfer_fsck_objects = -1;
31static int receive_unpack_limit = -1;
32static int transfer_unpack_limit = -1;
33static int unpack_limit = 100;
34static int report_status;
35static int use_sideband;
36static int quiet;
37static int prefer_ofs_delta = 1;
38static int auto_update_server_info;
39static int auto_gc = 1;
40static const char *head_name;
41static void *head_name_to_free;
42static int sent_capabilities;
43
44static enum deny_action parse_deny_action(const char *var, const char *value)
45{
46 if (value) {
47 if (!strcasecmp(value, "ignore"))
48 return DENY_IGNORE;
49 if (!strcasecmp(value, "warn"))
50 return DENY_WARN;
51 if (!strcasecmp(value, "refuse"))
52 return DENY_REFUSE;
53 }
54 if (git_config_bool(var, value))
55 return DENY_REFUSE;
56 return DENY_IGNORE;
57}
58
59static int receive_pack_config(const char *var, const char *value, void *cb)
60{
61 if (strcmp(var, "receive.denydeletes") == 0) {
62 deny_deletes = git_config_bool(var, value);
63 return 0;
64 }
65
66 if (strcmp(var, "receive.denynonfastforwards") == 0) {
67 deny_non_fast_forwards = git_config_bool(var, value);
68 return 0;
69 }
70
71 if (strcmp(var, "receive.unpacklimit") == 0) {
72 receive_unpack_limit = git_config_int(var, value);
73 return 0;
74 }
75
76 if (strcmp(var, "transfer.unpacklimit") == 0) {
77 transfer_unpack_limit = git_config_int(var, value);
78 return 0;
79 }
80
81 if (strcmp(var, "receive.fsckobjects") == 0) {
82 receive_fsck_objects = git_config_bool(var, value);
83 return 0;
84 }
85
86 if (strcmp(var, "transfer.fsckobjects") == 0) {
87 transfer_fsck_objects = git_config_bool(var, value);
88 return 0;
89 }
90
91 if (!strcmp(var, "receive.denycurrentbranch")) {
92 deny_current_branch = parse_deny_action(var, value);
93 return 0;
94 }
95
96 if (strcmp(var, "receive.denydeletecurrent") == 0) {
97 deny_delete_current = parse_deny_action(var, value);
98 return 0;
99 }
100
101 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
102 prefer_ofs_delta = git_config_bool(var, value);
103 return 0;
104 }
105
106 if (strcmp(var, "receive.updateserverinfo") == 0) {
107 auto_update_server_info = git_config_bool(var, value);
108 return 0;
109 }
110
111 if (strcmp(var, "receive.autogc") == 0) {
112 auto_gc = git_config_bool(var, value);
113 return 0;
114 }
115
116 return git_default_config(var, value, cb);
117}
118
119static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
120{
121 if (sent_capabilities)
122 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
123 else
124 packet_write(1, "%s %s%c%s%s\n",
125 sha1_to_hex(sha1), path, 0,
126 " report-status delete-refs side-band-64k quiet",
127 prefer_ofs_delta ? " ofs-delta" : "");
128 sent_capabilities = 1;
129 return 0;
130}
131
132static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *cb_data)
133{
134 path = strip_namespace(path);
135 /*
136 * Advertise refs outside our current namespace as ".have"
137 * refs, so that the client can use them to minimize data
138 * transfer but will otherwise ignore them. This happens to
139 * cover ".have" that are thrown in by add_one_alternate_ref()
140 * to mark histories that are complete in our alternates as
141 * well.
142 */
143 if (!path)
144 path = ".have";
145 return show_ref(path, sha1, flag, cb_data);
146}
147
148static void write_head_info(void)
149{
150 for_each_ref(show_ref_cb, NULL);
151 if (!sent_capabilities)
152 show_ref("capabilities^{}", null_sha1, 0, NULL);
153
154}
155
156struct command {
157 struct command *next;
158 const char *error_string;
159 unsigned int skip_update:1,
160 did_not_exist:1;
161 unsigned char old_sha1[20];
162 unsigned char new_sha1[20];
163 char ref_name[FLEX_ARRAY]; /* more */
164};
165
166static const char pre_receive_hook[] = "hooks/pre-receive";
167static const char post_receive_hook[] = "hooks/post-receive";
168
169static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
170static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
171
172static void report_message(const char *prefix, const char *err, va_list params)
173{
174 int sz = strlen(prefix);
175 char msg[4096];
176
177 strncpy(msg, prefix, sz);
178 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
179 if (sz > (sizeof(msg) - 1))
180 sz = sizeof(msg) - 1;
181 msg[sz++] = '\n';
182
183 if (use_sideband)
184 send_sideband(1, 2, msg, sz, use_sideband);
185 else
186 xwrite(2, msg, sz);
187}
188
189static void rp_warning(const char *err, ...)
190{
191 va_list params;
192 va_start(params, err);
193 report_message("warning: ", err, params);
194 va_end(params);
195}
196
197static void rp_error(const char *err, ...)
198{
199 va_list params;
200 va_start(params, err);
201 report_message("error: ", err, params);
202 va_end(params);
203}
204
205static int copy_to_sideband(int in, int out, void *arg)
206{
207 char data[128];
208 while (1) {
209 ssize_t sz = xread(in, data, sizeof(data));
210 if (sz <= 0)
211 break;
212 send_sideband(1, 2, data, sz, use_sideband);
213 }
214 close(in);
215 return 0;
216}
217
218typedef int (*feed_fn)(void *, const char **, size_t *);
219static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
220{
221 struct child_process proc;
222 struct async muxer;
223 const char *argv[2];
224 int code;
225
226 if (access(hook_name, X_OK) < 0)
227 return 0;
228
229 argv[0] = hook_name;
230 argv[1] = NULL;
231
232 memset(&proc, 0, sizeof(proc));
233 proc.argv = argv;
234 proc.in = -1;
235 proc.stdout_to_stderr = 1;
236
237 if (use_sideband) {
238 memset(&muxer, 0, sizeof(muxer));
239 muxer.proc = copy_to_sideband;
240 muxer.in = -1;
241 code = start_async(&muxer);
242 if (code)
243 return code;
244 proc.err = muxer.in;
245 }
246
247 code = start_command(&proc);
248 if (code) {
249 if (use_sideband)
250 finish_async(&muxer);
251 return code;
252 }
253
254 while (1) {
255 const char *buf;
256 size_t n;
257 if (feed(feed_state, &buf, &n))
258 break;
259 if (write_in_full(proc.in, buf, n) != n)
260 break;
261 }
262 close(proc.in);
263 if (use_sideband)
264 finish_async(&muxer);
265 return finish_command(&proc);
266}
267
268struct receive_hook_feed_state {
269 struct command *cmd;
270 int skip_broken;
271 struct strbuf buf;
272};
273
274static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
275{
276 struct receive_hook_feed_state *state = state_;
277 struct command *cmd = state->cmd;
278
279 while (cmd &&
280 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
281 cmd = cmd->next;
282 if (!cmd)
283 return -1; /* EOF */
284 strbuf_reset(&state->buf);
285 strbuf_addf(&state->buf, "%s %s %s\n",
286 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
287 cmd->ref_name);
288 state->cmd = cmd->next;
289 if (bufp) {
290 *bufp = state->buf.buf;
291 *sizep = state->buf.len;
292 }
293 return 0;
294}
295
296static int run_receive_hook(struct command *commands, const char *hook_name,
297 int skip_broken)
298{
299 struct receive_hook_feed_state state;
300 int status;
301
302 strbuf_init(&state.buf, 0);
303 state.cmd = commands;
304 state.skip_broken = skip_broken;
305 if (feed_receive_hook(&state, NULL, NULL))
306 return 0;
307 state.cmd = commands;
308 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
309 strbuf_release(&state.buf);
310 return status;
311}
312
313static int run_update_hook(struct command *cmd)
314{
315 static const char update_hook[] = "hooks/update";
316 const char *argv[5];
317 struct child_process proc;
318 int code;
319
320 if (access(update_hook, X_OK) < 0)
321 return 0;
322
323 argv[0] = update_hook;
324 argv[1] = cmd->ref_name;
325 argv[2] = sha1_to_hex(cmd->old_sha1);
326 argv[3] = sha1_to_hex(cmd->new_sha1);
327 argv[4] = NULL;
328
329 memset(&proc, 0, sizeof(proc));
330 proc.no_stdin = 1;
331 proc.stdout_to_stderr = 1;
332 proc.err = use_sideband ? -1 : 0;
333 proc.argv = argv;
334
335 code = start_command(&proc);
336 if (code)
337 return code;
338 if (use_sideband)
339 copy_to_sideband(proc.err, -1, NULL);
340 return finish_command(&proc);
341}
342
343static int is_ref_checked_out(const char *ref)
344{
345 if (is_bare_repository())
346 return 0;
347
348 if (!head_name)
349 return 0;
350 return !strcmp(head_name, ref);
351}
352
353static char *refuse_unconfigured_deny_msg[] = {
354 "By default, updating the current branch in a non-bare repository",
355 "is denied, because it will make the index and work tree inconsistent",
356 "with what you pushed, and will require 'git reset --hard' to match",
357 "the work tree to HEAD.",
358 "",
359 "You can set 'receive.denyCurrentBranch' configuration variable to",
360 "'ignore' or 'warn' in the remote repository to allow pushing into",
361 "its current branch; however, this is not recommended unless you",
362 "arranged to update its work tree to match what you pushed in some",
363 "other way.",
364 "",
365 "To squelch this message and still keep the default behaviour, set",
366 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
367};
368
369static void refuse_unconfigured_deny(void)
370{
371 int i;
372 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
373 rp_error("%s", refuse_unconfigured_deny_msg[i]);
374}
375
376static char *refuse_unconfigured_deny_delete_current_msg[] = {
377 "By default, deleting the current branch is denied, because the next",
378 "'git clone' won't result in any file checked out, causing confusion.",
379 "",
380 "You can set 'receive.denyDeleteCurrent' configuration variable to",
381 "'warn' or 'ignore' in the remote repository to allow deleting the",
382 "current branch, with or without a warning message.",
383 "",
384 "To squelch this message, you can set it to 'refuse'."
385};
386
387static void refuse_unconfigured_deny_delete_current(void)
388{
389 int i;
390 for (i = 0;
391 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
392 i++)
393 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
394}
395
396static const char *update(struct command *cmd)
397{
398 const char *name = cmd->ref_name;
399 struct strbuf namespaced_name_buf = STRBUF_INIT;
400 const char *namespaced_name;
401 unsigned char *old_sha1 = cmd->old_sha1;
402 unsigned char *new_sha1 = cmd->new_sha1;
403 struct ref_lock *lock;
404
405 /* only refs/... are allowed */
406 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
407 rp_error("refusing to create funny ref '%s' remotely", name);
408 return "funny refname";
409 }
410
411 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
412 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
413
414 if (is_ref_checked_out(namespaced_name)) {
415 switch (deny_current_branch) {
416 case DENY_IGNORE:
417 break;
418 case DENY_WARN:
419 rp_warning("updating the current branch");
420 break;
421 case DENY_REFUSE:
422 case DENY_UNCONFIGURED:
423 rp_error("refusing to update checked out branch: %s", name);
424 if (deny_current_branch == DENY_UNCONFIGURED)
425 refuse_unconfigured_deny();
426 return "branch is currently checked out";
427 }
428 }
429
430 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
431 error("unpack should have generated %s, "
432 "but I can't find it!", sha1_to_hex(new_sha1));
433 return "bad pack";
434 }
435
436 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
437 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
438 rp_error("denying ref deletion for %s", name);
439 return "deletion prohibited";
440 }
441
442 if (!strcmp(namespaced_name, head_name)) {
443 switch (deny_delete_current) {
444 case DENY_IGNORE:
445 break;
446 case DENY_WARN:
447 rp_warning("deleting the current branch");
448 break;
449 case DENY_REFUSE:
450 case DENY_UNCONFIGURED:
451 if (deny_delete_current == DENY_UNCONFIGURED)
452 refuse_unconfigured_deny_delete_current();
453 rp_error("refusing to delete the current branch: %s", name);
454 return "deletion of the current branch prohibited";
455 }
456 }
457 }
458
459 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
460 !is_null_sha1(old_sha1) &&
461 !prefixcmp(name, "refs/heads/")) {
462 struct object *old_object, *new_object;
463 struct commit *old_commit, *new_commit;
464 struct commit_list *bases, *ent;
465
466 old_object = parse_object(old_sha1);
467 new_object = parse_object(new_sha1);
468
469 if (!old_object || !new_object ||
470 old_object->type != OBJ_COMMIT ||
471 new_object->type != OBJ_COMMIT) {
472 error("bad sha1 objects for %s", name);
473 return "bad ref";
474 }
475 old_commit = (struct commit *)old_object;
476 new_commit = (struct commit *)new_object;
477 bases = get_merge_bases(old_commit, new_commit, 1);
478 for (ent = bases; ent; ent = ent->next)
479 if (!hashcmp(old_sha1, ent->item->object.sha1))
480 break;
481 free_commit_list(bases);
482 if (!ent) {
483 rp_error("denying non-fast-forward %s"
484 " (you should pull first)", name);
485 return "non-fast-forward";
486 }
487 }
488 if (run_update_hook(cmd)) {
489 rp_error("hook declined to update %s", name);
490 return "hook declined";
491 }
492
493 if (is_null_sha1(new_sha1)) {
494 if (!parse_object(old_sha1)) {
495 old_sha1 = NULL;
496 if (ref_exists(name)) {
497 rp_warning("Allowing deletion of corrupt ref.");
498 } else {
499 rp_warning("Deleting a non-existent ref.");
500 cmd->did_not_exist = 1;
501 }
502 }
503 if (delete_ref(namespaced_name, old_sha1, 0)) {
504 rp_error("failed to delete %s", name);
505 return "failed to delete";
506 }
507 return NULL; /* good */
508 }
509 else {
510 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
511 if (!lock) {
512 rp_error("failed to lock %s", name);
513 return "failed to lock";
514 }
515 if (write_ref_sha1(lock, new_sha1, "push")) {
516 return "failed to write"; /* error() already called */
517 }
518 return NULL; /* good */
519 }
520}
521
522static char update_post_hook[] = "hooks/post-update";
523
524static void run_update_post_hook(struct command *commands)
525{
526 struct command *cmd;
527 int argc;
528 const char **argv;
529 struct child_process proc;
530
531 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
532 if (cmd->error_string || cmd->did_not_exist)
533 continue;
534 argc++;
535 }
536 if (!argc || access(update_post_hook, X_OK) < 0)
537 return;
538 argv = xmalloc(sizeof(*argv) * (2 + argc));
539 argv[0] = update_post_hook;
540
541 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
542 char *p;
543 if (cmd->error_string || cmd->did_not_exist)
544 continue;
545 p = xmalloc(strlen(cmd->ref_name) + 1);
546 strcpy(p, cmd->ref_name);
547 argv[argc] = p;
548 argc++;
549 }
550 argv[argc] = NULL;
551
552 memset(&proc, 0, sizeof(proc));
553 proc.no_stdin = 1;
554 proc.stdout_to_stderr = 1;
555 proc.err = use_sideband ? -1 : 0;
556 proc.argv = argv;
557
558 if (!start_command(&proc)) {
559 if (use_sideband)
560 copy_to_sideband(proc.err, -1, NULL);
561 finish_command(&proc);
562 }
563}
564
565static void check_aliased_update(struct command *cmd, struct string_list *list)
566{
567 struct strbuf buf = STRBUF_INIT;
568 const char *dst_name;
569 struct string_list_item *item;
570 struct command *dst_cmd;
571 unsigned char sha1[20];
572 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
573 int flag;
574
575 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
576 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
577 strbuf_release(&buf);
578
579 if (!(flag & REF_ISSYMREF))
580 return;
581
582 dst_name = strip_namespace(dst_name);
583 if (!dst_name) {
584 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
585 cmd->skip_update = 1;
586 cmd->error_string = "broken symref";
587 return;
588 }
589
590 if ((item = string_list_lookup(list, dst_name)) == NULL)
591 return;
592
593 cmd->skip_update = 1;
594
595 dst_cmd = (struct command *) item->util;
596
597 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
598 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
599 return;
600
601 dst_cmd->skip_update = 1;
602
603 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
604 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
605 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
606 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
607 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
608 " its target '%s' (%s..%s)",
609 cmd->ref_name, cmd_oldh, cmd_newh,
610 dst_cmd->ref_name, dst_oldh, dst_newh);
611
612 cmd->error_string = dst_cmd->error_string =
613 "inconsistent aliased update";
614}
615
616static void check_aliased_updates(struct command *commands)
617{
618 struct command *cmd;
619 struct string_list ref_list = STRING_LIST_INIT_NODUP;
620
621 for (cmd = commands; cmd; cmd = cmd->next) {
622 struct string_list_item *item =
623 string_list_append(&ref_list, cmd->ref_name);
624 item->util = (void *)cmd;
625 }
626 sort_string_list(&ref_list);
627
628 for (cmd = commands; cmd; cmd = cmd->next)
629 check_aliased_update(cmd, &ref_list);
630
631 string_list_clear(&ref_list, 0);
632}
633
634static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
635{
636 struct command **cmd_list = cb_data;
637 struct command *cmd = *cmd_list;
638
639 if (!cmd || is_null_sha1(cmd->new_sha1))
640 return -1; /* end of list */
641 *cmd_list = NULL; /* this returns only one */
642 hashcpy(sha1, cmd->new_sha1);
643 return 0;
644}
645
646static void set_connectivity_errors(struct command *commands)
647{
648 struct command *cmd;
649
650 for (cmd = commands; cmd; cmd = cmd->next) {
651 struct command *singleton = cmd;
652 if (!check_everything_connected(command_singleton_iterator,
653 0, &singleton))
654 continue;
655 cmd->error_string = "missing necessary objects";
656 }
657}
658
659static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
660{
661 struct command **cmd_list = cb_data;
662 struct command *cmd = *cmd_list;
663
664 while (cmd) {
665 if (!is_null_sha1(cmd->new_sha1)) {
666 hashcpy(sha1, cmd->new_sha1);
667 *cmd_list = cmd->next;
668 return 0;
669 }
670 cmd = cmd->next;
671 }
672 *cmd_list = NULL;
673 return -1; /* end of list */
674}
675
676static void execute_commands(struct command *commands, const char *unpacker_error)
677{
678 struct command *cmd;
679 unsigned char sha1[20];
680
681 if (unpacker_error) {
682 for (cmd = commands; cmd; cmd = cmd->next)
683 cmd->error_string = "n/a (unpacker error)";
684 return;
685 }
686
687 cmd = commands;
688 if (check_everything_connected(iterate_receive_command_list,
689 0, &cmd))
690 set_connectivity_errors(commands);
691
692 if (run_receive_hook(commands, pre_receive_hook, 0)) {
693 for (cmd = commands; cmd; cmd = cmd->next)
694 cmd->error_string = "pre-receive hook declined";
695 return;
696 }
697
698 check_aliased_updates(commands);
699
700 free(head_name_to_free);
701 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
702
703 for (cmd = commands; cmd; cmd = cmd->next)
704 if (!cmd->skip_update)
705 cmd->error_string = update(cmd);
706}
707
708static struct command *read_head_info(void)
709{
710 struct command *commands = NULL;
711 struct command **p = &commands;
712 for (;;) {
713 static char line[1000];
714 unsigned char old_sha1[20], new_sha1[20];
715 struct command *cmd;
716 char *refname;
717 int len, reflen;
718
719 len = packet_read_line(0, line, sizeof(line));
720 if (!len)
721 break;
722 if (line[len-1] == '\n')
723 line[--len] = 0;
724 if (len < 83 ||
725 line[40] != ' ' ||
726 line[81] != ' ' ||
727 get_sha1_hex(line, old_sha1) ||
728 get_sha1_hex(line + 41, new_sha1))
729 die("protocol error: expected old/new/ref, got '%s'",
730 line);
731
732 refname = line + 82;
733 reflen = strlen(refname);
734 if (reflen + 82 < len) {
735 const char *feature_list = refname + reflen + 1;
736 if (parse_feature_request(feature_list, "report-status"))
737 report_status = 1;
738 if (parse_feature_request(feature_list, "side-band-64k"))
739 use_sideband = LARGE_PACKET_MAX;
740 if (parse_feature_request(feature_list, "quiet"))
741 quiet = 1;
742 }
743 cmd = xcalloc(1, sizeof(struct command) + len - 80);
744 hashcpy(cmd->old_sha1, old_sha1);
745 hashcpy(cmd->new_sha1, new_sha1);
746 memcpy(cmd->ref_name, line + 82, len - 81);
747 *p = cmd;
748 p = &cmd->next;
749 }
750 return commands;
751}
752
753static const char *parse_pack_header(struct pack_header *hdr)
754{
755 switch (read_pack_header(0, hdr)) {
756 case PH_ERROR_EOF:
757 return "eof before pack header was fully read";
758
759 case PH_ERROR_PACK_SIGNATURE:
760 return "protocol error (pack signature mismatch detected)";
761
762 case PH_ERROR_PROTOCOL:
763 return "protocol error (pack version unsupported)";
764
765 default:
766 return "unknown error in parse_pack_header";
767
768 case 0:
769 return NULL;
770 }
771}
772
773static const char *pack_lockfile;
774
775static const char *unpack(void)
776{
777 struct pack_header hdr;
778 const char *hdr_err;
779 char hdr_arg[38];
780 int fsck_objects = (receive_fsck_objects >= 0
781 ? receive_fsck_objects
782 : transfer_fsck_objects >= 0
783 ? transfer_fsck_objects
784 : 0);
785
786 hdr_err = parse_pack_header(&hdr);
787 if (hdr_err)
788 return hdr_err;
789 snprintf(hdr_arg, sizeof(hdr_arg),
790 "--pack_header=%"PRIu32",%"PRIu32,
791 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
792
793 if (ntohl(hdr.hdr_entries) < unpack_limit) {
794 int code, i = 0;
795 const char *unpacker[5];
796 unpacker[i++] = "unpack-objects";
797 if (quiet)
798 unpacker[i++] = "-q";
799 if (fsck_objects)
800 unpacker[i++] = "--strict";
801 unpacker[i++] = hdr_arg;
802 unpacker[i++] = NULL;
803 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
804 if (!code)
805 return NULL;
806 return "unpack-objects abnormal exit";
807 } else {
808 const char *keeper[7];
809 int s, status, i = 0;
810 char keep_arg[256];
811 struct child_process ip;
812
813 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
814 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
815 strcpy(keep_arg + s, "localhost");
816
817 keeper[i++] = "index-pack";
818 keeper[i++] = "--stdin";
819 if (fsck_objects)
820 keeper[i++] = "--strict";
821 keeper[i++] = "--fix-thin";
822 keeper[i++] = hdr_arg;
823 keeper[i++] = keep_arg;
824 keeper[i++] = NULL;
825 memset(&ip, 0, sizeof(ip));
826 ip.argv = keeper;
827 ip.out = -1;
828 ip.git_cmd = 1;
829 status = start_command(&ip);
830 if (status) {
831 return "index-pack fork failed";
832 }
833 pack_lockfile = index_pack_lockfile(ip.out);
834 close(ip.out);
835 status = finish_command(&ip);
836 if (!status) {
837 reprepare_packed_git();
838 return NULL;
839 }
840 return "index-pack abnormal exit";
841 }
842}
843
844static void report(struct command *commands, const char *unpack_status)
845{
846 struct command *cmd;
847 struct strbuf buf = STRBUF_INIT;
848
849 packet_buf_write(&buf, "unpack %s\n",
850 unpack_status ? unpack_status : "ok");
851 for (cmd = commands; cmd; cmd = cmd->next) {
852 if (!cmd->error_string)
853 packet_buf_write(&buf, "ok %s\n",
854 cmd->ref_name);
855 else
856 packet_buf_write(&buf, "ng %s %s\n",
857 cmd->ref_name, cmd->error_string);
858 }
859 packet_buf_flush(&buf);
860
861 if (use_sideband)
862 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
863 else
864 safe_write(1, buf.buf, buf.len);
865 strbuf_release(&buf);
866}
867
868static int delete_only(struct command *commands)
869{
870 struct command *cmd;
871 for (cmd = commands; cmd; cmd = cmd->next) {
872 if (!is_null_sha1(cmd->new_sha1))
873 return 0;
874 }
875 return 1;
876}
877
878static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
879{
880 add_extra_ref(".have", sha1, 0);
881}
882
883static void collect_one_alternate_ref(const struct ref *ref, void *data)
884{
885 struct sha1_array *sa = data;
886 sha1_array_append(sa, ref->old_sha1);
887}
888
889static void add_alternate_refs(void)
890{
891 struct sha1_array sa = SHA1_ARRAY_INIT;
892 for_each_alternate_ref(collect_one_alternate_ref, &sa);
893 sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
894 sha1_array_clear(&sa);
895}
896
897int cmd_receive_pack(int argc, const char **argv, const char *prefix)
898{
899 int advertise_refs = 0;
900 int stateless_rpc = 0;
901 int i;
902 char *dir = NULL;
903 struct command *commands;
904
905 packet_trace_identity("receive-pack");
906
907 argv++;
908 for (i = 1; i < argc; i++) {
909 const char *arg = *argv++;
910
911 if (*arg == '-') {
912 if (!strcmp(arg, "--quiet")) {
913 quiet = 1;
914 continue;
915 }
916
917 if (!strcmp(arg, "--advertise-refs")) {
918 advertise_refs = 1;
919 continue;
920 }
921 if (!strcmp(arg, "--stateless-rpc")) {
922 stateless_rpc = 1;
923 continue;
924 }
925
926 usage(receive_pack_usage);
927 }
928 if (dir)
929 usage(receive_pack_usage);
930 dir = xstrdup(arg);
931 }
932 if (!dir)
933 usage(receive_pack_usage);
934
935 setup_path();
936
937 if (!enter_repo(dir, 0))
938 die("'%s' does not appear to be a git repository", dir);
939
940 if (is_repository_shallow())
941 die("attempt to push into a shallow repository");
942
943 git_config(receive_pack_config, NULL);
944
945 if (0 <= transfer_unpack_limit)
946 unpack_limit = transfer_unpack_limit;
947 else if (0 <= receive_unpack_limit)
948 unpack_limit = receive_unpack_limit;
949
950 if (advertise_refs || !stateless_rpc) {
951 add_alternate_refs();
952 write_head_info();
953 clear_extra_refs();
954
955 /* EOF */
956 packet_flush(1);
957 }
958 if (advertise_refs)
959 return 0;
960
961 if ((commands = read_head_info()) != NULL) {
962 const char *unpack_status = NULL;
963
964 if (!delete_only(commands))
965 unpack_status = unpack();
966 execute_commands(commands, unpack_status);
967 if (pack_lockfile)
968 unlink_or_warn(pack_lockfile);
969 if (report_status)
970 report(commands, unpack_status);
971 run_receive_hook(commands, post_receive_hook, 1);
972 run_update_post_hook(commands);
973 if (auto_gc) {
974 const char *argv_gc_auto[] = {
975 "gc", "--auto", "--quiet", NULL,
976 };
977 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
978 }
979 if (auto_update_server_info)
980 update_server_info(0);
981 }
982 if (use_sideband)
983 packet_flush(1);
984 return 0;
985}