add 'git credential' plumbing command
[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"
575f4974 15
34263de0 16static const char receive_pack_usage[] = "git receive-pack <git-dir>";
575f4974 17
986e8239 18enum deny_action {
3d95d92b 19 DENY_UNCONFIGURED,
986e8239
JK
20 DENY_IGNORE,
21 DENY_WARN,
4b05548f 22 DENY_REFUSE
986e8239
JK
23};
24
1b53a076
JH
25static int deny_deletes;
26static int deny_non_fast_forwards;
3d95d92b 27static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
747ca245 28static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
dab76d3a
JH
29static int receive_fsck_objects = -1;
30static int transfer_fsck_objects = -1;
e28714c5
JH
31static int receive_unpack_limit = -1;
32static int transfer_unpack_limit = -1;
46732fae 33static int unpack_limit = 100;
96f1e58f 34static int report_status;
38a81b4e 35static int use_sideband;
c207e34f 36static int quiet;
b74fce16 37static int prefer_ofs_delta = 1;
77e3efbf
JH
38static int auto_update_server_info;
39static int auto_gc = 1;
747ca245 40static const char *head_name;
96ec7b1e 41static void *head_name_to_free;
185c04e0 42static int sent_capabilities;
cfee10a7 43
986e8239
JK
44static 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
ef90d6d4 59static int receive_pack_config(const char *var, const char *value, void *cb)
6fb75bed 60{
a240de11
JK
61 if (strcmp(var, "receive.denydeletes") == 0) {
62 deny_deletes = git_config_bool(var, value);
63 return 0;
64 }
65
e28714c5 66 if (strcmp(var, "receive.denynonfastforwards") == 0) {
6fb75bed
SP
67 deny_non_fast_forwards = git_config_bool(var, value);
68 return 0;
69 }
70
e28714c5
JH
71 if (strcmp(var, "receive.unpacklimit") == 0) {
72 receive_unpack_limit = git_config_int(var, value);
fc04c412
SP
73 return 0;
74 }
75
e28714c5
JH
76 if (strcmp(var, "transfer.unpacklimit") == 0) {
77 transfer_unpack_limit = git_config_int(var, value);
78 return 0;
79 }
80
20dc0016
MK
81 if (strcmp(var, "receive.fsckobjects") == 0) {
82 receive_fsck_objects = git_config_bool(var, value);
83 return 0;
84 }
85
dab76d3a
JH
86 if (strcmp(var, "transfer.fsckobjects") == 0) {
87 transfer_fsck_objects = git_config_bool(var, value);
88 return 0;
89 }
90
986e8239
JK
91 if (!strcmp(var, "receive.denycurrentbranch")) {
92 deny_current_branch = parse_deny_action(var, value);
93 return 0;
94 }
95
747ca245
JH
96 if (strcmp(var, "receive.denydeletecurrent") == 0) {
97 deny_delete_current = parse_deny_action(var, value);
98 return 0;
99 }
100
b74fce16
NP
101 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
102 prefer_ofs_delta = git_config_bool(var, value);
103 return 0;
104 }
105
77e3efbf
JH
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
ef90d6d4 116 return git_default_config(var, value, cb);
6fb75bed
SP
117}
118
bc98201d 119static void show_ref(const char *path, const unsigned char *sha1)
575f4974 120{
185c04e0 121 if (sent_capabilities)
cfee10a7
JH
122 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
123 else
185c04e0
SP
124 packet_write(1, "%s %s%c%s%s\n",
125 sha1_to_hex(sha1), path, 0,
c207e34f 126 " report-status delete-refs side-band-64k quiet",
185c04e0
SP
127 prefer_ofs_delta ? " ofs-delta" : "");
128 sent_capabilities = 1;
575f4974
LT
129}
130
bc98201d 131static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
6b01ecfe
JT
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";
bc98201d
MH
144 show_ref(path, sha1);
145 return 0;
6b01ecfe
JT
146}
147
85f25104 148static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
b7a025d9 149{
85f25104 150 show_ref(".have", sha1);
b7a025d9
MH
151}
152
153static 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);
6b01ecfe
JT
157}
158
8a65ff76 159static void write_head_info(void)
575f4974 160{
b7a025d9
MH
161 struct sha1_array sa = SHA1_ARRAY_INIT;
162 for_each_alternate_ref(collect_one_alternate_ref, &sa);
85f25104 163 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
b7a025d9 164 sha1_array_clear(&sa);
6b01ecfe 165 for_each_ref(show_ref_cb, NULL);
185c04e0 166 if (!sent_capabilities)
bc98201d 167 show_ref("capabilities^{}", null_sha1);
cfee10a7 168
b7a025d9
MH
169 /* EOF */
170 packet_flush(1);
575f4974
LT
171}
172
eb1af2df
LT
173struct command {
174 struct command *next;
cfee10a7 175 const char *error_string;
160b81ed
PYH
176 unsigned int skip_update:1,
177 did_not_exist:1;
eb1af2df
LT
178 unsigned char old_sha1[20];
179 unsigned char new_sha1[20];
8f1d2e6f 180 char ref_name[FLEX_ARRAY]; /* more */
575f4974
LT
181};
182
05ef58ec
SP
183static const char pre_receive_hook[] = "hooks/pre-receive";
184static const char post_receive_hook[] = "hooks/post-receive";
b1bf95bb 185
466dbc42
SP
186static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
187static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
188
189static 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
206static 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
214static 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
6d525d38
SP
222static 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
9684e44a
JH
235typedef int (*feed_fn)(void *, const char **, size_t *);
236static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
b1bf95bb 237{
f43cd49f 238 struct child_process proc;
6d525d38 239 struct async muxer;
f43cd49f 240 const char *argv[2];
9684e44a 241 int code;
b1bf95bb 242
9684e44a 243 if (access(hook_name, X_OK) < 0)
b1bf95bb 244 return 0;
c8dd2771 245
c8dd2771 246 argv[0] = hook_name;
f43cd49f
SP
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
6d525d38
SP
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
f43cd49f 264 code = start_command(&proc);
6d525d38
SP
265 if (code) {
266 if (use_sideband)
267 finish_async(&muxer);
90e41a89 268 return code;
6d525d38
SP
269 }
270
9684e44a
JH
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;
c8dd2771 278 }
e72ae288 279 close(proc.in);
6d525d38
SP
280 if (use_sideband)
281 finish_async(&muxer);
90e41a89 282 return finish_command(&proc);
b1bf95bb
JW
283}
284
9684e44a
JH
285struct receive_hook_feed_state {
286 struct command *cmd;
cdc2b2f3 287 int skip_broken;
9684e44a
JH
288 struct strbuf buf;
289};
290
291static 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
cdc2b2f3
JH
296 while (cmd &&
297 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
9684e44a
JH
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
cdc2b2f3
JH
313static int run_receive_hook(struct command *commands, const char *hook_name,
314 int skip_broken)
9684e44a
JH
315{
316 struct receive_hook_feed_state state;
317 int status;
318
319 strbuf_init(&state.buf, 0);
320 state.cmd = commands;
cdc2b2f3 321 state.skip_broken = skip_broken;
9684e44a
JH
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
1d9e8b56
SP
330static int run_update_hook(struct command *cmd)
331{
332 static const char update_hook[] = "hooks/update";
1d9e8b56 333 const char *argv[5];
6d525d38
SP
334 struct child_process proc;
335 int code;
1d9e8b56
SP
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
6d525d38
SP
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);
1d9e8b56
SP
358}
359
986e8239
JK
360static int is_ref_checked_out(const char *ref)
361{
986e8239
JK
362 if (is_bare_repository())
363 return 0;
364
747ca245 365 if (!head_name)
986e8239 366 return 0;
747ca245 367 return !strcmp(head_name, ref);
986e8239
JK
368}
369
acd2a45b
JH
370static 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.",
3d95d92b
JH
375 "",
376 "You can set 'receive.denyCurrentBranch' configuration variable to",
acd2a45b
JH
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.",
3d95d92b 381 "",
acd2a45b
JH
382 "To squelch this message and still keep the default behaviour, set",
383 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
3d95d92b
JH
384};
385
acd2a45b 386static void refuse_unconfigured_deny(void)
3d95d92b
JH
387{
388 int i;
acd2a45b 389 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
a886ba28 390 rp_error("%s", refuse_unconfigured_deny_msg[i]);
3d95d92b
JH
391}
392
375881fa
JH
393static 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.",
747ca245
JH
396 "",
397 "You can set 'receive.denyDeleteCurrent' configuration variable to",
375881fa
JH
398 "'warn' or 'ignore' in the remote repository to allow deleting the",
399 "current branch, with or without a warning message.",
747ca245 400 "",
375881fa 401 "To squelch this message, you can set it to 'refuse'."
747ca245
JH
402};
403
375881fa 404static void refuse_unconfigured_deny_delete_current(void)
747ca245
JH
405{
406 int i;
407 for (i = 0;
375881fa 408 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
747ca245 409 i++)
a886ba28 410 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
747ca245
JH
411}
412
8aaf7d64 413static const char *update(struct command *cmd)
2eca23da 414{
cfee10a7 415 const char *name = cmd->ref_name;
6b01ecfe
JT
416 struct strbuf namespaced_name_buf = STRBUF_INIT;
417 const char *namespaced_name;
cfee10a7
JH
418 unsigned char *old_sha1 = cmd->old_sha1;
419 unsigned char *new_sha1 = cmd->new_sha1;
3159c8dc 420 struct ref_lock *lock;
2eca23da 421
061d6b9a 422 /* only refs/... are allowed */
8d9c5010 423 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
466dbc42 424 rp_error("refusing to create funny ref '%s' remotely", name);
8aaf7d64 425 return "funny refname";
cfee10a7 426 }
d8a1deec 427
6b01ecfe
JT
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)) {
3d95d92b
JH
432 switch (deny_current_branch) {
433 case DENY_IGNORE:
986e8239 434 break;
3d95d92b 435 case DENY_WARN:
466dbc42 436 rp_warning("updating the current branch");
986e8239 437 break;
3d95d92b 438 case DENY_REFUSE:
acd2a45b 439 case DENY_UNCONFIGURED:
466dbc42 440 rp_error("refusing to update checked out branch: %s", name);
acd2a45b
JH
441 if (deny_current_branch == DENY_UNCONFIGURED)
442 refuse_unconfigured_deny();
3d95d92b
JH
443 return "branch is currently checked out";
444 }
986e8239
JK
445 }
446
d4f694ba 447 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
8aaf7d64
SP
448 error("unpack should have generated %s, "
449 "but I can't find it!", sha1_to_hex(new_sha1));
450 return "bad pack";
cfee10a7 451 }
747ca245
JH
452
453 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
454 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
466dbc42 455 rp_error("denying ref deletion for %s", name);
747ca245
JH
456 return "deletion prohibited";
457 }
458
6b01ecfe 459 if (!strcmp(namespaced_name, head_name)) {
747ca245
JH
460 switch (deny_delete_current) {
461 case DENY_IGNORE:
462 break;
463 case DENY_WARN:
466dbc42 464 rp_warning("deleting the current branch");
747ca245
JH
465 break;
466 case DENY_REFUSE:
375881fa
JH
467 case DENY_UNCONFIGURED:
468 if (deny_delete_current == DENY_UNCONFIGURED)
469 refuse_unconfigured_deny_delete_current();
466dbc42 470 rp_error("refusing to delete the current branch: %s", name);
747ca245
JH
471 return "deletion of the current branch prohibited";
472 }
473 }
a240de11 474 }
747ca245 475
d4f694ba 476 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
ba988a83 477 !is_null_sha1(old_sha1) &&
cc44c765 478 !prefixcmp(name, "refs/heads/")) {
eab82707 479 struct object *old_object, *new_object;
11031d7e 480 struct commit *old_commit, *new_commit;
9edd7e46 481 struct commit_list *bases, *ent;
11031d7e 482
eab82707
MK
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;
9edd7e46
JS
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))
11031d7e 497 break;
9edd7e46 498 free_commit_list(bases);
8aaf7d64 499 if (!ent) {
466dbc42
SP
500 rp_error("denying non-fast-forward %s"
501 " (you should pull first)", name);
a75d7b54 502 return "non-fast-forward";
8aaf7d64 503 }
11031d7e 504 }
1d9e8b56 505 if (run_update_hook(cmd)) {
466dbc42 506 rp_error("hook declined to update %s", name);
8aaf7d64 507 return "hook declined";
b1bf95bb 508 }
3159c8dc 509
d4f694ba 510 if (is_null_sha1(new_sha1)) {
28391a80 511 if (!parse_object(old_sha1)) {
28391a80 512 old_sha1 = NULL;
160b81ed
PYH
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 }
28391a80 519 }
6b01ecfe 520 if (delete_ref(namespaced_name, old_sha1, 0)) {
466dbc42 521 rp_error("failed to delete %s", name);
8aaf7d64 522 return "failed to delete";
d4f694ba 523 }
8aaf7d64 524 return NULL; /* good */
d4f694ba
JH
525 }
526 else {
6b01ecfe 527 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
d4f694ba 528 if (!lock) {
466dbc42 529 rp_error("failed to lock %s", name);
8aaf7d64 530 return "failed to lock";
d4f694ba 531 }
ef203f08 532 if (write_ref_sha1(lock, new_sha1, "push")) {
8aaf7d64 533 return "failed to write"; /* error() already called */
ef203f08 534 }
8aaf7d64 535 return NULL; /* good */
19614330 536 }
2eca23da
LT
537}
538
19614330
JH
539static char update_post_hook[] = "hooks/post-update";
540
5e1c71fd 541static void run_update_post_hook(struct command *commands)
19614330 542{
5e1c71fd 543 struct command *cmd;
6d525d38 544 int argc;
9201c707 545 const char **argv;
6d525d38 546 struct child_process proc;
19614330 547
5e1c71fd 548 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
160b81ed 549 if (cmd->error_string || cmd->did_not_exist)
19614330
JH
550 continue;
551 argc++;
552 }
3e6e152c
SP
553 if (!argc || access(update_post_hook, X_OK) < 0)
554 return;
555 argv = xmalloc(sizeof(*argv) * (2 + argc));
19614330
JH
556 argv[0] = update_post_hook;
557
5e1c71fd 558 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
9201c707 559 char *p;
160b81ed 560 if (cmd->error_string || cmd->did_not_exist)
19614330 561 continue;
5e1c71fd
JS
562 p = xmalloc(strlen(cmd->ref_name) + 1);
563 strcpy(p, cmd->ref_name);
9201c707 564 argv[argc] = p;
19614330
JH
565 argc++;
566 }
567 argv[argc] = NULL;
6d525d38
SP
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 }
19614330 580}
2eca23da 581
da3efdb1
JS
582static void check_aliased_update(struct command *cmd, struct string_list *list)
583{
6b01ecfe
JT
584 struct strbuf buf = STRBUF_INIT;
585 const char *dst_name;
da3efdb1
JS
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
6b01ecfe 592 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
8cad4744 593 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
6b01ecfe 594 strbuf_release(&buf);
da3efdb1
JS
595
596 if (!(flag & REF_ISSYMREF))
597 return;
598
6b01ecfe
JT
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
e8c8b713 607 if ((item = string_list_lookup(list, dst_name)) == NULL)
da3efdb1
JS
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));
0e71bc30 621 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
da3efdb1 622 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
0e71bc30 623 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
da3efdb1
JS
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
633static void check_aliased_updates(struct command *commands)
634{
635 struct command *cmd;
183113a5 636 struct string_list ref_list = STRING_LIST_INIT_NODUP;
da3efdb1
JS
637
638 for (cmd = commands; cmd; cmd = cmd->next) {
639 struct string_list_item *item =
1d2f80fa 640 string_list_append(&ref_list, cmd->ref_name);
da3efdb1
JS
641 item->util = (void *)cmd;
642 }
643 sort_string_list(&ref_list);
644
ef7e93d9
CB
645 for (cmd = commands; cmd; cmd = cmd->next) {
646 if (!cmd->error_string)
647 check_aliased_update(cmd, &ref_list);
648 }
da3efdb1
JS
649
650 string_list_clear(&ref_list, 0);
651}
652
52fed6e1
JH
653static 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
ee6dfb2d 658 if (!cmd || is_null_sha1(cmd->new_sha1))
52fed6e1
JH
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
665static 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
678static 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
ee6dfb2d
JH
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 */
52fed6e1
JH
693}
694
5e1c71fd 695static void execute_commands(struct command *commands, const char *unpacker_error)
575f4974 696{
5e1c71fd 697 struct command *cmd;
747ca245 698 unsigned char sha1[20];
8aaf7d64
SP
699
700 if (unpacker_error) {
5e1c71fd 701 for (cmd = commands; cmd; cmd = cmd->next)
8aaf7d64 702 cmd->error_string = "n/a (unpacker error)";
8aaf7d64
SP
703 return;
704 }
705
52fed6e1
JH
706 cmd = commands;
707 if (check_everything_connected(iterate_receive_command_list,
708 0, &cmd))
709 set_connectivity_errors(commands);
710
cdc2b2f3 711 if (run_receive_hook(commands, pre_receive_hook, 0)) {
ef7e93d9
CB
712 for (cmd = commands; cmd; cmd = cmd->next) {
713 if (!cmd->error_string)
714 cmd->error_string = "pre-receive hook declined";
715 }
05ef58ec
SP
716 return;
717 }
718
da3efdb1
JS
719 check_aliased_updates(commands);
720
96ec7b1e
NTND
721 free(head_name_to_free);
722 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
747ca245 723
ef7e93d9
CB
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 }
575f4974
LT
733}
734
5e1c71fd 735static struct command *read_head_info(void)
575f4974 736{
5e1c71fd 737 struct command *commands = NULL;
eb1af2df 738 struct command **p = &commands;
575f4974
LT
739 for (;;) {
740 static char line[1000];
eb1af2df
LT
741 unsigned char old_sha1[20], new_sha1[20];
742 struct command *cmd;
cfee10a7
JH
743 char *refname;
744 int len, reflen;
eb1af2df
LT
745
746 len = packet_read_line(0, line, sizeof(line));
575f4974
LT
747 if (!len)
748 break;
eb1af2df
LT
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))
cfee10a7
JH
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) {
f47182c8
JH
762 const char *feature_list = refname + reflen + 1;
763 if (parse_feature_request(feature_list, "report-status"))
cfee10a7 764 report_status = 1;
f47182c8 765 if (parse_feature_request(feature_list, "side-band-64k"))
38a81b4e 766 use_sideband = LARGE_PACKET_MAX;
c207e34f
CB
767 if (parse_feature_request(feature_list, "quiet"))
768 quiet = 1;
cfee10a7 769 }
da3efdb1 770 cmd = xcalloc(1, sizeof(struct command) + len - 80);
e702496e
SP
771 hashcpy(cmd->old_sha1, old_sha1);
772 hashcpy(cmd->new_sha1, new_sha1);
eb1af2df 773 memcpy(cmd->ref_name, line + 82, len - 81);
eb1af2df
LT
774 *p = cmd;
775 p = &cmd->next;
575f4974 776 }
5e1c71fd 777 return commands;
575f4974
LT
778}
779
fc04c412
SP
780static const char *parse_pack_header(struct pack_header *hdr)
781{
a69e5429
JH
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:
fc04c412 787 return "protocol error (pack signature mismatch detected)";
a69e5429
JH
788
789 case PH_ERROR_PROTOCOL:
fc04c412 790 return "protocol error (pack version unsupported)";
a69e5429
JH
791
792 default:
793 return "unknown error in parse_pack_header";
794
795 case 0:
796 return NULL;
797 }
fc04c412
SP
798}
799
576162a4
NP
800static const char *pack_lockfile;
801
5a277f3f 802static const char *unpack(void)
575f4974 803{
fc04c412
SP
804 struct pack_header hdr;
805 const char *hdr_err;
806 char hdr_arg[38];
dab76d3a
JH
807 int fsck_objects = (receive_fsck_objects >= 0
808 ? receive_fsck_objects
809 : transfer_fsck_objects >= 0
810 ? transfer_fsck_objects
811 : 0);
fc04c412
SP
812
813 hdr_err = parse_pack_header(&hdr);
814 if (hdr_err)
815 return hdr_err;
6e1c2344
RJ
816 snprintf(hdr_arg, sizeof(hdr_arg),
817 "--pack_header=%"PRIu32",%"PRIu32,
fc04c412
SP
818 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
819
820 if (ntohl(hdr.hdr_entries) < unpack_limit) {
20dc0016 821 int code, i = 0;
c207e34f 822 const char *unpacker[5];
20dc0016 823 unpacker[i++] = "unpack-objects";
c207e34f
CB
824 if (quiet)
825 unpacker[i++] = "-q";
dab76d3a 826 if (fsck_objects)
20dc0016
MK
827 unpacker[i++] = "--strict";
828 unpacker[i++] = hdr_arg;
829 unpacker[i++] = NULL;
9b0b5093 830 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
2ff4d1ab 831 if (!code)
fc04c412 832 return NULL;
2ff4d1ab 833 return "unpack-objects abnormal exit";
576162a4 834 } else {
20dc0016
MK
835 const char *keeper[7];
836 int s, status, i = 0;
576162a4 837 char keep_arg[256];
e8016abf 838 struct child_process ip;
576162a4 839
85e72830 840 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
576162a4
NP
841 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
842 strcpy(keep_arg + s, "localhost");
843
20dc0016
MK
844 keeper[i++] = "index-pack";
845 keeper[i++] = "--stdin";
dab76d3a 846 if (fsck_objects)
20dc0016
MK
847 keeper[i++] = "--strict";
848 keeper[i++] = "--fix-thin";
849 keeper[i++] = hdr_arg;
850 keeper[i++] = keep_arg;
851 keeper[i++] = NULL;
e8016abf
SP
852 memset(&ip, 0, sizeof(ip));
853 ip.argv = keeper;
854 ip.out = -1;
855 ip.git_cmd = 1;
2ff4d1ab
JS
856 status = start_command(&ip);
857 if (status) {
576162a4 858 return "index-pack fork failed";
2ff4d1ab 859 }
106764e6 860 pack_lockfile = index_pack_lockfile(ip.out);
e72ae288 861 close(ip.out);
e8016abf
SP
862 status = finish_command(&ip);
863 if (!status) {
576162a4
NP
864 reprepare_packed_git();
865 return NULL;
866 }
867 return "index-pack abnormal exit";
cfee10a7
JH
868 }
869}
870
5e1c71fd 871static void report(struct command *commands, const char *unpack_status)
cfee10a7
JH
872{
873 struct command *cmd;
38a81b4e
SP
874 struct strbuf buf = STRBUF_INIT;
875
876 packet_buf_write(&buf, "unpack %s\n",
877 unpack_status ? unpack_status : "ok");
cfee10a7
JH
878 for (cmd = commands; cmd; cmd = cmd->next) {
879 if (!cmd->error_string)
38a81b4e
SP
880 packet_buf_write(&buf, "ok %s\n",
881 cmd->ref_name);
cfee10a7 882 else
38a81b4e
SP
883 packet_buf_write(&buf, "ng %s %s\n",
884 cmd->ref_name, cmd->error_string);
575f4974 885 }
38a81b4e
SP
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);
575f4974
LT
893}
894
5e1c71fd 895static int delete_only(struct command *commands)
d4f694ba 896{
5e1c71fd
JS
897 struct command *cmd;
898 for (cmd = commands; cmd; cmd = cmd->next) {
d4f694ba
JH
899 if (!is_null_sha1(cmd->new_sha1))
900 return 0;
d4f694ba
JH
901 }
902 return 1;
903}
904
be5908ae 905int cmd_receive_pack(int argc, const char **argv, const char *prefix)
575f4974 906{
42526b47
SP
907 int advertise_refs = 0;
908 int stateless_rpc = 0;
d0efc8a7 909 int i;
8d630132 910 char *dir = NULL;
5e1c71fd 911 struct command *commands;
575f4974 912
bbc30f99
JK
913 packet_trace_identity("receive-pack");
914
575f4974
LT
915 argv++;
916 for (i = 1; i < argc; i++) {
be5908ae 917 const char *arg = *argv++;
575f4974
LT
918
919 if (*arg == '-') {
c207e34f
CB
920 if (!strcmp(arg, "--quiet")) {
921 quiet = 1;
922 continue;
923 }
924
42526b47
SP
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
575f4974
LT
934 usage(receive_pack_usage);
935 }
d0efc8a7
LT
936 if (dir)
937 usage(receive_pack_usage);
be5908ae 938 dir = xstrdup(arg);
575f4974
LT
939 }
940 if (!dir)
941 usage(receive_pack_usage);
942
e1464ca7 943 setup_path();
5c09f321 944
3159c8dc 945 if (!enter_repo(dir, 0))
05ac6b34 946 die("'%s' does not appear to be a git repository", dir);
575f4974 947
a0022eeb
JH
948 if (is_repository_shallow())
949 die("attempt to push into a shallow repository");
950
ef90d6d4 951 git_config(receive_pack_config, NULL);
6fb75bed 952
e28714c5
JH
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
42526b47 958 if (advertise_refs || !stateless_rpc) {
42526b47 959 write_head_info();
42526b47
SP
960 }
961 if (advertise_refs)
962 return 0;
575f4974 963
5e1c71fd 964 if ((commands = read_head_info()) != NULL) {
d4f694ba
JH
965 const char *unpack_status = NULL;
966
967 if (!delete_only(commands))
5a277f3f 968 unpack_status = unpack();
5e1c71fd 969 execute_commands(commands, unpack_status);
576162a4 970 if (pack_lockfile)
691f1a28 971 unlink_or_warn(pack_lockfile);
cfee10a7 972 if (report_status)
5e1c71fd 973 report(commands, unpack_status);
cdc2b2f3 974 run_receive_hook(commands, post_receive_hook, 1);
8e663d9e 975 run_update_post_hook(commands);
77e3efbf
JH
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);
7f8e9828 984 }
38a81b4e
SP
985 if (use_sideband)
986 packet_flush(1);
575f4974
LT
987 return 0;
988}