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