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