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