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