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