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