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