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