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