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