builtin/receive-pack: fix incorrect pointer arithmetic
[git/git.git] / builtin / receive-pack.c
1 #include "builtin.h"
2 #include "pack.h"
3 #include "refs.h"
4 #include "pkt-line.h"
5 #include "sideband.h"
6 #include "run-command.h"
7 #include "exec_cmd.h"
8 #include "commit.h"
9 #include "object.h"
10 #include "remote.h"
11 #include "connect.h"
12 #include "transport.h"
13 #include "string-list.h"
14 #include "sha1-array.h"
15 #include "connected.h"
16 #include "argv-array.h"
17 #include "version.h"
18 #include "tag.h"
19 #include "gpg-interface.h"
20
21 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
22
23 enum deny_action {
24 DENY_UNCONFIGURED,
25 DENY_IGNORE,
26 DENY_WARN,
27 DENY_REFUSE
28 };
29
30 static int deny_deletes;
31 static int deny_non_fast_forwards;
32 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
33 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
34 static int receive_fsck_objects = -1;
35 static int transfer_fsck_objects = -1;
36 static int receive_unpack_limit = -1;
37 static int transfer_unpack_limit = -1;
38 static int unpack_limit = 100;
39 static int report_status;
40 static int use_sideband;
41 static int quiet;
42 static int prefer_ofs_delta = 1;
43 static int auto_update_server_info;
44 static int auto_gc = 1;
45 static int fix_thin = 1;
46 static int stateless_rpc;
47 static const char *service_dir;
48 static const char *head_name;
49 static void *head_name_to_free;
50 static int sent_capabilities;
51 static int shallow_update;
52 static const char *alt_shallow_file;
53 static struct strbuf push_cert = STRBUF_INIT;
54 static unsigned char push_cert_sha1[20];
55 static struct signature_check sigcheck;
56 static const char *push_cert_nonce;
57 static const char *cert_nonce_seed;
58
59 static const char *NONCE_UNSOLICITED = "UNSOLICITED";
60 static const char *NONCE_BAD = "BAD";
61 static const char *NONCE_MISSING = "MISSING";
62 static const char *NONCE_OK = "OK";
63 static const char *NONCE_SLOP = "SLOP";
64 static const char *nonce_status;
65 static long nonce_stamp_slop;
66 static unsigned long nonce_stamp_slop_limit;
67
68 static enum deny_action parse_deny_action(const char *var, const char *value)
69 {
70 if (value) {
71 if (!strcasecmp(value, "ignore"))
72 return DENY_IGNORE;
73 if (!strcasecmp(value, "warn"))
74 return DENY_WARN;
75 if (!strcasecmp(value, "refuse"))
76 return DENY_REFUSE;
77 }
78 if (git_config_bool(var, value))
79 return DENY_REFUSE;
80 return DENY_IGNORE;
81 }
82
83 static int receive_pack_config(const char *var, const char *value, void *cb)
84 {
85 int status = parse_hide_refs_config(var, value, "receive");
86
87 if (status)
88 return status;
89
90 if (strcmp(var, "receive.denydeletes") == 0) {
91 deny_deletes = git_config_bool(var, value);
92 return 0;
93 }
94
95 if (strcmp(var, "receive.denynonfastforwards") == 0) {
96 deny_non_fast_forwards = git_config_bool(var, value);
97 return 0;
98 }
99
100 if (strcmp(var, "receive.unpacklimit") == 0) {
101 receive_unpack_limit = git_config_int(var, value);
102 return 0;
103 }
104
105 if (strcmp(var, "transfer.unpacklimit") == 0) {
106 transfer_unpack_limit = git_config_int(var, value);
107 return 0;
108 }
109
110 if (strcmp(var, "receive.fsckobjects") == 0) {
111 receive_fsck_objects = git_config_bool(var, value);
112 return 0;
113 }
114
115 if (strcmp(var, "transfer.fsckobjects") == 0) {
116 transfer_fsck_objects = git_config_bool(var, value);
117 return 0;
118 }
119
120 if (!strcmp(var, "receive.denycurrentbranch")) {
121 deny_current_branch = parse_deny_action(var, value);
122 return 0;
123 }
124
125 if (strcmp(var, "receive.denydeletecurrent") == 0) {
126 deny_delete_current = parse_deny_action(var, value);
127 return 0;
128 }
129
130 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
131 prefer_ofs_delta = git_config_bool(var, value);
132 return 0;
133 }
134
135 if (strcmp(var, "receive.updateserverinfo") == 0) {
136 auto_update_server_info = git_config_bool(var, value);
137 return 0;
138 }
139
140 if (strcmp(var, "receive.autogc") == 0) {
141 auto_gc = git_config_bool(var, value);
142 return 0;
143 }
144
145 if (strcmp(var, "receive.shallowupdate") == 0) {
146 shallow_update = git_config_bool(var, value);
147 return 0;
148 }
149
150 if (strcmp(var, "receive.certnonceseed") == 0)
151 return git_config_string(&cert_nonce_seed, var, value);
152
153 if (strcmp(var, "receive.certnonceslop") == 0) {
154 nonce_stamp_slop_limit = git_config_ulong(var, value);
155 return 0;
156 }
157
158 return git_default_config(var, value, cb);
159 }
160
161 static void show_ref(const char *path, const unsigned char *sha1)
162 {
163 if (ref_is_hidden(path))
164 return;
165
166 if (sent_capabilities) {
167 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
168 } else {
169 struct strbuf cap = STRBUF_INIT;
170
171 strbuf_addstr(&cap,
172 "report-status delete-refs side-band-64k quiet");
173 if (prefer_ofs_delta)
174 strbuf_addstr(&cap, " ofs-delta");
175 if (push_cert_nonce)
176 strbuf_addf(&cap, " push-cert=%s", push_cert_nonce);
177 strbuf_addf(&cap, " agent=%s", git_user_agent_sanitized());
178 packet_write(1, "%s %s%c%s\n",
179 sha1_to_hex(sha1), path, 0, cap.buf);
180 strbuf_release(&cap);
181 sent_capabilities = 1;
182 }
183 }
184
185 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
186 {
187 path = strip_namespace(path);
188 /*
189 * Advertise refs outside our current namespace as ".have"
190 * refs, so that the client can use them to minimize data
191 * transfer but will otherwise ignore them. This happens to
192 * cover ".have" that are thrown in by add_one_alternate_ref()
193 * to mark histories that are complete in our alternates as
194 * well.
195 */
196 if (!path)
197 path = ".have";
198 show_ref(path, sha1);
199 return 0;
200 }
201
202 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
203 {
204 show_ref(".have", sha1);
205 }
206
207 static void collect_one_alternate_ref(const struct ref *ref, void *data)
208 {
209 struct sha1_array *sa = data;
210 sha1_array_append(sa, ref->old_sha1);
211 }
212
213 static void write_head_info(void)
214 {
215 struct sha1_array sa = SHA1_ARRAY_INIT;
216 for_each_alternate_ref(collect_one_alternate_ref, &sa);
217 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
218 sha1_array_clear(&sa);
219 for_each_ref(show_ref_cb, NULL);
220 if (!sent_capabilities)
221 show_ref("capabilities^{}", null_sha1);
222
223 advertise_shallow_grafts(1);
224
225 /* EOF */
226 packet_flush(1);
227 }
228
229 struct command {
230 struct command *next;
231 const char *error_string;
232 unsigned int skip_update:1,
233 did_not_exist:1;
234 int index;
235 unsigned char old_sha1[20];
236 unsigned char new_sha1[20];
237 char ref_name[FLEX_ARRAY]; /* more */
238 };
239
240 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
241 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
242
243 static void report_message(const char *prefix, const char *err, va_list params)
244 {
245 int sz = strlen(prefix);
246 char msg[4096];
247
248 strncpy(msg, prefix, sz);
249 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
250 if (sz > (sizeof(msg) - 1))
251 sz = sizeof(msg) - 1;
252 msg[sz++] = '\n';
253
254 if (use_sideband)
255 send_sideband(1, 2, msg, sz, use_sideband);
256 else
257 xwrite(2, msg, sz);
258 }
259
260 static void rp_warning(const char *err, ...)
261 {
262 va_list params;
263 va_start(params, err);
264 report_message("warning: ", err, params);
265 va_end(params);
266 }
267
268 static void rp_error(const char *err, ...)
269 {
270 va_list params;
271 va_start(params, err);
272 report_message("error: ", err, params);
273 va_end(params);
274 }
275
276 static int copy_to_sideband(int in, int out, void *arg)
277 {
278 char data[128];
279 while (1) {
280 ssize_t sz = xread(in, data, sizeof(data));
281 if (sz <= 0)
282 break;
283 send_sideband(1, 2, data, sz, use_sideband);
284 }
285 close(in);
286 return 0;
287 }
288
289 #define HMAC_BLOCK_SIZE 64
290
291 static void hmac_sha1(unsigned char *out,
292 const char *key_in, size_t key_len,
293 const char *text, size_t text_len)
294 {
295 unsigned char key[HMAC_BLOCK_SIZE];
296 unsigned char k_ipad[HMAC_BLOCK_SIZE];
297 unsigned char k_opad[HMAC_BLOCK_SIZE];
298 int i;
299 git_SHA_CTX ctx;
300
301 /* RFC 2104 2. (1) */
302 memset(key, '\0', HMAC_BLOCK_SIZE);
303 if (HMAC_BLOCK_SIZE < key_len) {
304 git_SHA1_Init(&ctx);
305 git_SHA1_Update(&ctx, key_in, key_len);
306 git_SHA1_Final(key, &ctx);
307 } else {
308 memcpy(key, key_in, key_len);
309 }
310
311 /* RFC 2104 2. (2) & (5) */
312 for (i = 0; i < sizeof(key); i++) {
313 k_ipad[i] = key[i] ^ 0x36;
314 k_opad[i] = key[i] ^ 0x5c;
315 }
316
317 /* RFC 2104 2. (3) & (4) */
318 git_SHA1_Init(&ctx);
319 git_SHA1_Update(&ctx, k_ipad, sizeof(k_ipad));
320 git_SHA1_Update(&ctx, text, text_len);
321 git_SHA1_Final(out, &ctx);
322
323 /* RFC 2104 2. (6) & (7) */
324 git_SHA1_Init(&ctx);
325 git_SHA1_Update(&ctx, k_opad, sizeof(k_opad));
326 git_SHA1_Update(&ctx, out, 20);
327 git_SHA1_Final(out, &ctx);
328 }
329
330 static char *prepare_push_cert_nonce(const char *path, unsigned long stamp)
331 {
332 struct strbuf buf = STRBUF_INIT;
333 unsigned char sha1[20];
334
335 strbuf_addf(&buf, "%s:%lu", path, stamp);
336 hmac_sha1(sha1, buf.buf, buf.len, cert_nonce_seed, strlen(cert_nonce_seed));;
337 strbuf_release(&buf);
338
339 /* RFC 2104 5. HMAC-SHA1-80 */
340 strbuf_addf(&buf, "%lu-%.*s", stamp, 20, sha1_to_hex(sha1));
341 return strbuf_detach(&buf, NULL);
342 }
343
344 /*
345 * NEEDSWORK: reuse find_commit_header() from jk/commit-author-parsing
346 * after dropping "_commit" from its name and possibly moving it out
347 * of commit.c
348 */
349 static char *find_header(const char *msg, size_t len, const char *key)
350 {
351 int key_len = strlen(key);
352 const char *line = msg;
353
354 while (line && line < msg + len) {
355 const char *eol = strchrnul(line, '\n');
356
357 if ((msg + len <= eol) || line == eol)
358 return NULL;
359 if (line + key_len < eol &&
360 !memcmp(line, key, key_len) && line[key_len] == ' ') {
361 int offset = key_len + 1;
362 return xmemdupz(line + offset, (eol - line) - offset);
363 }
364 line = *eol ? eol + 1 : NULL;
365 }
366 return NULL;
367 }
368
369 static const char *check_nonce(const char *buf, size_t len)
370 {
371 char *nonce = find_header(buf, len, "nonce");
372 unsigned long stamp, ostamp;
373 char *bohmac, *expect = NULL;
374 const char *retval = NONCE_BAD;
375
376 if (!nonce) {
377 retval = NONCE_MISSING;
378 goto leave;
379 } else if (!push_cert_nonce) {
380 retval = NONCE_UNSOLICITED;
381 goto leave;
382 } else if (!strcmp(push_cert_nonce, nonce)) {
383 retval = NONCE_OK;
384 goto leave;
385 }
386
387 if (!stateless_rpc) {
388 /* returned nonce MUST match what we gave out earlier */
389 retval = NONCE_BAD;
390 goto leave;
391 }
392
393 /*
394 * In stateless mode, we may be receiving a nonce issued by
395 * another instance of the server that serving the same
396 * repository, and the timestamps may not match, but the
397 * nonce-seed and dir should match, so we can recompute and
398 * report the time slop.
399 *
400 * In addition, when a nonce issued by another instance has
401 * timestamp within receive.certnonceslop seconds, we pretend
402 * as if we issued that nonce when reporting to the hook.
403 */
404
405 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
406 if (*nonce <= '0' || '9' < *nonce) {
407 retval = NONCE_BAD;
408 goto leave;
409 }
410 stamp = strtoul(nonce, &bohmac, 10);
411 if (bohmac == nonce || bohmac[0] != '-') {
412 retval = NONCE_BAD;
413 goto leave;
414 }
415
416 expect = prepare_push_cert_nonce(service_dir, stamp);
417 if (strcmp(expect, nonce)) {
418 /* Not what we would have signed earlier */
419 retval = NONCE_BAD;
420 goto leave;
421 }
422
423 /*
424 * By how many seconds is this nonce stale? Negative value
425 * would mean it was issued by another server with its clock
426 * skewed in the future.
427 */
428 ostamp = strtoul(push_cert_nonce, NULL, 10);
429 nonce_stamp_slop = (long)ostamp - (long)stamp;
430
431 if (nonce_stamp_slop_limit &&
432 abs(nonce_stamp_slop) <= nonce_stamp_slop_limit) {
433 /*
434 * Pretend as if the received nonce (which passes the
435 * HMAC check, so it is not a forged by third-party)
436 * is what we issued.
437 */
438 free((void *)push_cert_nonce);
439 push_cert_nonce = xstrdup(nonce);
440 retval = NONCE_OK;
441 } else {
442 retval = NONCE_SLOP;
443 }
444
445 leave:
446 free(nonce);
447 free(expect);
448 return retval;
449 }
450
451 static void prepare_push_cert_sha1(struct child_process *proc)
452 {
453 static int already_done;
454 struct argv_array env = ARGV_ARRAY_INIT;
455
456 if (!push_cert.len)
457 return;
458
459 if (!already_done) {
460 struct strbuf gpg_output = STRBUF_INIT;
461 struct strbuf gpg_status = STRBUF_INIT;
462 int bogs /* beginning_of_gpg_sig */;
463
464 already_done = 1;
465 if (write_sha1_file(push_cert.buf, push_cert.len, "blob", push_cert_sha1))
466 hashclr(push_cert_sha1);
467
468 memset(&sigcheck, '\0', sizeof(sigcheck));
469 sigcheck.result = 'N';
470
471 bogs = parse_signature(push_cert.buf, push_cert.len);
472 if (verify_signed_buffer(push_cert.buf, bogs,
473 push_cert.buf + bogs, push_cert.len - bogs,
474 &gpg_output, &gpg_status) < 0) {
475 ; /* error running gpg */
476 } else {
477 sigcheck.payload = push_cert.buf;
478 sigcheck.gpg_output = gpg_output.buf;
479 sigcheck.gpg_status = gpg_status.buf;
480 parse_gpg_output(&sigcheck);
481 }
482
483 strbuf_release(&gpg_output);
484 strbuf_release(&gpg_status);
485 nonce_status = check_nonce(push_cert.buf, bogs);
486 }
487 if (!is_null_sha1(push_cert_sha1)) {
488 argv_array_pushf(&env, "GIT_PUSH_CERT=%s", sha1_to_hex(push_cert_sha1));
489 argv_array_pushf(&env, "GIT_PUSH_CERT_SIGNER=%s",
490 sigcheck.signer ? sigcheck.signer : "");
491 argv_array_pushf(&env, "GIT_PUSH_CERT_KEY=%s",
492 sigcheck.key ? sigcheck.key : "");
493 argv_array_pushf(&env, "GIT_PUSH_CERT_STATUS=%c", sigcheck.result);
494 if (push_cert_nonce) {
495 argv_array_pushf(&env, "GIT_PUSH_CERT_NONCE=%s", push_cert_nonce);
496 argv_array_pushf(&env, "GIT_PUSH_CERT_NONCE_STATUS=%s", nonce_status);
497 if (nonce_status == NONCE_SLOP)
498 argv_array_pushf(&env, "GIT_PUSH_CERT_NONCE_SLOP=%ld",
499 nonce_stamp_slop);
500 }
501 proc->env = env.argv;
502 }
503 }
504
505 typedef int (*feed_fn)(void *, const char **, size_t *);
506 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
507 {
508 struct child_process proc;
509 struct async muxer;
510 const char *argv[2];
511 int code;
512
513 argv[0] = find_hook(hook_name);
514 if (!argv[0])
515 return 0;
516
517 argv[1] = NULL;
518
519 memset(&proc, 0, sizeof(proc));
520 proc.argv = argv;
521 proc.in = -1;
522 proc.stdout_to_stderr = 1;
523
524 prepare_push_cert_sha1(&proc);
525
526 if (use_sideband) {
527 memset(&muxer, 0, sizeof(muxer));
528 muxer.proc = copy_to_sideband;
529 muxer.in = -1;
530 code = start_async(&muxer);
531 if (code)
532 return code;
533 proc.err = muxer.in;
534 }
535
536 code = start_command(&proc);
537 if (code) {
538 if (use_sideband)
539 finish_async(&muxer);
540 return code;
541 }
542
543 while (1) {
544 const char *buf;
545 size_t n;
546 if (feed(feed_state, &buf, &n))
547 break;
548 if (write_in_full(proc.in, buf, n) != n)
549 break;
550 }
551 close(proc.in);
552 if (use_sideband)
553 finish_async(&muxer);
554 return finish_command(&proc);
555 }
556
557 struct receive_hook_feed_state {
558 struct command *cmd;
559 int skip_broken;
560 struct strbuf buf;
561 };
562
563 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
564 {
565 struct receive_hook_feed_state *state = state_;
566 struct command *cmd = state->cmd;
567
568 while (cmd &&
569 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
570 cmd = cmd->next;
571 if (!cmd)
572 return -1; /* EOF */
573 strbuf_reset(&state->buf);
574 strbuf_addf(&state->buf, "%s %s %s\n",
575 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
576 cmd->ref_name);
577 state->cmd = cmd->next;
578 if (bufp) {
579 *bufp = state->buf.buf;
580 *sizep = state->buf.len;
581 }
582 return 0;
583 }
584
585 static int run_receive_hook(struct command *commands, const char *hook_name,
586 int skip_broken)
587 {
588 struct receive_hook_feed_state state;
589 int status;
590
591 strbuf_init(&state.buf, 0);
592 state.cmd = commands;
593 state.skip_broken = skip_broken;
594 if (feed_receive_hook(&state, NULL, NULL))
595 return 0;
596 state.cmd = commands;
597 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
598 strbuf_release(&state.buf);
599 return status;
600 }
601
602 static int run_update_hook(struct command *cmd)
603 {
604 const char *argv[5];
605 struct child_process proc;
606 int code;
607
608 argv[0] = find_hook("update");
609 if (!argv[0])
610 return 0;
611
612 argv[1] = cmd->ref_name;
613 argv[2] = sha1_to_hex(cmd->old_sha1);
614 argv[3] = sha1_to_hex(cmd->new_sha1);
615 argv[4] = NULL;
616
617 memset(&proc, 0, sizeof(proc));
618 proc.no_stdin = 1;
619 proc.stdout_to_stderr = 1;
620 proc.err = use_sideband ? -1 : 0;
621 proc.argv = argv;
622
623 code = start_command(&proc);
624 if (code)
625 return code;
626 if (use_sideband)
627 copy_to_sideband(proc.err, -1, NULL);
628 return finish_command(&proc);
629 }
630
631 static int is_ref_checked_out(const char *ref)
632 {
633 if (is_bare_repository())
634 return 0;
635
636 if (!head_name)
637 return 0;
638 return !strcmp(head_name, ref);
639 }
640
641 static char *refuse_unconfigured_deny_msg[] = {
642 "By default, updating the current branch in a non-bare repository",
643 "is denied, because it will make the index and work tree inconsistent",
644 "with what you pushed, and will require 'git reset --hard' to match",
645 "the work tree to HEAD.",
646 "",
647 "You can set 'receive.denyCurrentBranch' configuration variable to",
648 "'ignore' or 'warn' in the remote repository to allow pushing into",
649 "its current branch; however, this is not recommended unless you",
650 "arranged to update its work tree to match what you pushed in some",
651 "other way.",
652 "",
653 "To squelch this message and still keep the default behaviour, set",
654 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
655 };
656
657 static void refuse_unconfigured_deny(void)
658 {
659 int i;
660 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
661 rp_error("%s", refuse_unconfigured_deny_msg[i]);
662 }
663
664 static char *refuse_unconfigured_deny_delete_current_msg[] = {
665 "By default, deleting the current branch is denied, because the next",
666 "'git clone' won't result in any file checked out, causing confusion.",
667 "",
668 "You can set 'receive.denyDeleteCurrent' configuration variable to",
669 "'warn' or 'ignore' in the remote repository to allow deleting the",
670 "current branch, with or without a warning message.",
671 "",
672 "To squelch this message, you can set it to 'refuse'."
673 };
674
675 static void refuse_unconfigured_deny_delete_current(void)
676 {
677 int i;
678 for (i = 0;
679 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
680 i++)
681 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
682 }
683
684 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
685 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
686 {
687 static struct lock_file shallow_lock;
688 struct sha1_array extra = SHA1_ARRAY_INIT;
689 const char *alt_file;
690 uint32_t mask = 1 << (cmd->index % 32);
691 int i;
692
693 trace_printf_key(&trace_shallow,
694 "shallow: update_shallow_ref %s\n", cmd->ref_name);
695 for (i = 0; i < si->shallow->nr; i++)
696 if (si->used_shallow[i] &&
697 (si->used_shallow[i][cmd->index / 32] & mask) &&
698 !delayed_reachability_test(si, i))
699 sha1_array_append(&extra, si->shallow->sha1[i]);
700
701 setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
702 if (check_shallow_connected(command_singleton_iterator,
703 0, cmd, alt_file)) {
704 rollback_lock_file(&shallow_lock);
705 sha1_array_clear(&extra);
706 return -1;
707 }
708
709 commit_lock_file(&shallow_lock);
710
711 /*
712 * Make sure setup_alternate_shallow() for the next ref does
713 * not lose these new roots..
714 */
715 for (i = 0; i < extra.nr; i++)
716 register_shallow(extra.sha1[i]);
717
718 si->shallow_ref[cmd->index] = 0;
719 sha1_array_clear(&extra);
720 return 0;
721 }
722
723 static const char *update(struct command *cmd, struct shallow_info *si)
724 {
725 const char *name = cmd->ref_name;
726 struct strbuf namespaced_name_buf = STRBUF_INIT;
727 const char *namespaced_name;
728 unsigned char *old_sha1 = cmd->old_sha1;
729 unsigned char *new_sha1 = cmd->new_sha1;
730 struct ref_lock *lock;
731
732 /* only refs/... are allowed */
733 if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
734 rp_error("refusing to create funny ref '%s' remotely", name);
735 return "funny refname";
736 }
737
738 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
739 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
740
741 if (is_ref_checked_out(namespaced_name)) {
742 switch (deny_current_branch) {
743 case DENY_IGNORE:
744 break;
745 case DENY_WARN:
746 rp_warning("updating the current branch");
747 break;
748 case DENY_REFUSE:
749 case DENY_UNCONFIGURED:
750 rp_error("refusing to update checked out branch: %s", name);
751 if (deny_current_branch == DENY_UNCONFIGURED)
752 refuse_unconfigured_deny();
753 return "branch is currently checked out";
754 }
755 }
756
757 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
758 error("unpack should have generated %s, "
759 "but I can't find it!", sha1_to_hex(new_sha1));
760 return "bad pack";
761 }
762
763 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
764 if (deny_deletes && starts_with(name, "refs/heads/")) {
765 rp_error("denying ref deletion for %s", name);
766 return "deletion prohibited";
767 }
768
769 if (!strcmp(namespaced_name, head_name)) {
770 switch (deny_delete_current) {
771 case DENY_IGNORE:
772 break;
773 case DENY_WARN:
774 rp_warning("deleting the current branch");
775 break;
776 case DENY_REFUSE:
777 case DENY_UNCONFIGURED:
778 if (deny_delete_current == DENY_UNCONFIGURED)
779 refuse_unconfigured_deny_delete_current();
780 rp_error("refusing to delete the current branch: %s", name);
781 return "deletion of the current branch prohibited";
782 }
783 }
784 }
785
786 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
787 !is_null_sha1(old_sha1) &&
788 starts_with(name, "refs/heads/")) {
789 struct object *old_object, *new_object;
790 struct commit *old_commit, *new_commit;
791
792 old_object = parse_object(old_sha1);
793 new_object = parse_object(new_sha1);
794
795 if (!old_object || !new_object ||
796 old_object->type != OBJ_COMMIT ||
797 new_object->type != OBJ_COMMIT) {
798 error("bad sha1 objects for %s", name);
799 return "bad ref";
800 }
801 old_commit = (struct commit *)old_object;
802 new_commit = (struct commit *)new_object;
803 if (!in_merge_bases(old_commit, new_commit)) {
804 rp_error("denying non-fast-forward %s"
805 " (you should pull first)", name);
806 return "non-fast-forward";
807 }
808 }
809 if (run_update_hook(cmd)) {
810 rp_error("hook declined to update %s", name);
811 return "hook declined";
812 }
813
814 if (is_null_sha1(new_sha1)) {
815 if (!parse_object(old_sha1)) {
816 old_sha1 = NULL;
817 if (ref_exists(name)) {
818 rp_warning("Allowing deletion of corrupt ref.");
819 } else {
820 rp_warning("Deleting a non-existent ref.");
821 cmd->did_not_exist = 1;
822 }
823 }
824 if (delete_ref(namespaced_name, old_sha1, 0)) {
825 rp_error("failed to delete %s", name);
826 return "failed to delete";
827 }
828 return NULL; /* good */
829 }
830 else {
831 if (shallow_update && si->shallow_ref[cmd->index] &&
832 update_shallow_ref(cmd, si))
833 return "shallow error";
834
835 lock = lock_any_ref_for_update(namespaced_name, old_sha1,
836 0, NULL);
837 if (!lock) {
838 rp_error("failed to lock %s", name);
839 return "failed to lock";
840 }
841 if (write_ref_sha1(lock, new_sha1, "push")) {
842 return "failed to write"; /* error() already called */
843 }
844 return NULL; /* good */
845 }
846 }
847
848 static void run_update_post_hook(struct command *commands)
849 {
850 struct command *cmd;
851 int argc;
852 const char **argv;
853 struct child_process proc;
854 char *hook;
855
856 hook = find_hook("post-update");
857 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
858 if (cmd->error_string || cmd->did_not_exist)
859 continue;
860 argc++;
861 }
862 if (!argc || !hook)
863 return;
864
865 argv = xmalloc(sizeof(*argv) * (2 + argc));
866 argv[0] = hook;
867
868 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
869 if (cmd->error_string || cmd->did_not_exist)
870 continue;
871 argv[argc] = xstrdup(cmd->ref_name);
872 argc++;
873 }
874 argv[argc] = NULL;
875
876 memset(&proc, 0, sizeof(proc));
877 proc.no_stdin = 1;
878 proc.stdout_to_stderr = 1;
879 proc.err = use_sideband ? -1 : 0;
880 proc.argv = argv;
881
882 if (!start_command(&proc)) {
883 if (use_sideband)
884 copy_to_sideband(proc.err, -1, NULL);
885 finish_command(&proc);
886 }
887 }
888
889 static void check_aliased_update(struct command *cmd, struct string_list *list)
890 {
891 struct strbuf buf = STRBUF_INIT;
892 const char *dst_name;
893 struct string_list_item *item;
894 struct command *dst_cmd;
895 unsigned char sha1[20];
896 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
897 int flag;
898
899 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
900 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
901 strbuf_release(&buf);
902
903 if (!(flag & REF_ISSYMREF))
904 return;
905
906 dst_name = strip_namespace(dst_name);
907 if (!dst_name) {
908 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
909 cmd->skip_update = 1;
910 cmd->error_string = "broken symref";
911 return;
912 }
913
914 if ((item = string_list_lookup(list, dst_name)) == NULL)
915 return;
916
917 cmd->skip_update = 1;
918
919 dst_cmd = (struct command *) item->util;
920
921 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
922 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
923 return;
924
925 dst_cmd->skip_update = 1;
926
927 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
928 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
929 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
930 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
931 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
932 " its target '%s' (%s..%s)",
933 cmd->ref_name, cmd_oldh, cmd_newh,
934 dst_cmd->ref_name, dst_oldh, dst_newh);
935
936 cmd->error_string = dst_cmd->error_string =
937 "inconsistent aliased update";
938 }
939
940 static void check_aliased_updates(struct command *commands)
941 {
942 struct command *cmd;
943 struct string_list ref_list = STRING_LIST_INIT_NODUP;
944
945 for (cmd = commands; cmd; cmd = cmd->next) {
946 struct string_list_item *item =
947 string_list_append(&ref_list, cmd->ref_name);
948 item->util = (void *)cmd;
949 }
950 sort_string_list(&ref_list);
951
952 for (cmd = commands; cmd; cmd = cmd->next) {
953 if (!cmd->error_string)
954 check_aliased_update(cmd, &ref_list);
955 }
956
957 string_list_clear(&ref_list, 0);
958 }
959
960 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
961 {
962 struct command **cmd_list = cb_data;
963 struct command *cmd = *cmd_list;
964
965 if (!cmd || is_null_sha1(cmd->new_sha1))
966 return -1; /* end of list */
967 *cmd_list = NULL; /* this returns only one */
968 hashcpy(sha1, cmd->new_sha1);
969 return 0;
970 }
971
972 static void set_connectivity_errors(struct command *commands,
973 struct shallow_info *si)
974 {
975 struct command *cmd;
976
977 for (cmd = commands; cmd; cmd = cmd->next) {
978 struct command *singleton = cmd;
979 if (shallow_update && si->shallow_ref[cmd->index])
980 /* to be checked in update_shallow_ref() */
981 continue;
982 if (!check_everything_connected(command_singleton_iterator,
983 0, &singleton))
984 continue;
985 cmd->error_string = "missing necessary objects";
986 }
987 }
988
989 struct iterate_data {
990 struct command *cmds;
991 struct shallow_info *si;
992 };
993
994 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
995 {
996 struct iterate_data *data = cb_data;
997 struct command **cmd_list = &data->cmds;
998 struct command *cmd = *cmd_list;
999
1000 for (; cmd; cmd = cmd->next) {
1001 if (shallow_update && data->si->shallow_ref[cmd->index])
1002 /* to be checked in update_shallow_ref() */
1003 continue;
1004 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
1005 hashcpy(sha1, cmd->new_sha1);
1006 *cmd_list = cmd->next;
1007 return 0;
1008 }
1009 }
1010 *cmd_list = NULL;
1011 return -1; /* end of list */
1012 }
1013
1014 static void reject_updates_to_hidden(struct command *commands)
1015 {
1016 struct command *cmd;
1017
1018 for (cmd = commands; cmd; cmd = cmd->next) {
1019 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
1020 continue;
1021 if (is_null_sha1(cmd->new_sha1))
1022 cmd->error_string = "deny deleting a hidden ref";
1023 else
1024 cmd->error_string = "deny updating a hidden ref";
1025 }
1026 }
1027
1028 static void execute_commands(struct command *commands,
1029 const char *unpacker_error,
1030 struct shallow_info *si)
1031 {
1032 int checked_connectivity;
1033 struct command *cmd;
1034 unsigned char sha1[20];
1035 struct iterate_data data;
1036
1037 if (unpacker_error) {
1038 for (cmd = commands; cmd; cmd = cmd->next)
1039 cmd->error_string = "unpacker error";
1040 return;
1041 }
1042
1043 data.cmds = commands;
1044 data.si = si;
1045 if (check_everything_connected(iterate_receive_command_list, 0, &data))
1046 set_connectivity_errors(commands, si);
1047
1048 reject_updates_to_hidden(commands);
1049
1050 if (run_receive_hook(commands, "pre-receive", 0)) {
1051 for (cmd = commands; cmd; cmd = cmd->next) {
1052 if (!cmd->error_string)
1053 cmd->error_string = "pre-receive hook declined";
1054 }
1055 return;
1056 }
1057
1058 check_aliased_updates(commands);
1059
1060 free(head_name_to_free);
1061 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
1062
1063 checked_connectivity = 1;
1064 for (cmd = commands; cmd; cmd = cmd->next) {
1065 if (cmd->error_string)
1066 continue;
1067
1068 if (cmd->skip_update)
1069 continue;
1070
1071 cmd->error_string = update(cmd, si);
1072 if (shallow_update && !cmd->error_string &&
1073 si->shallow_ref[cmd->index]) {
1074 error("BUG: connectivity check has not been run on ref %s",
1075 cmd->ref_name);
1076 checked_connectivity = 0;
1077 }
1078 }
1079
1080 if (shallow_update && !checked_connectivity)
1081 error("BUG: run 'git fsck' for safety.\n"
1082 "If there are errors, try to remove "
1083 "the reported refs above");
1084 }
1085
1086 static struct command **queue_command(struct command **tail,
1087 const char *line,
1088 int linelen)
1089 {
1090 unsigned char old_sha1[20], new_sha1[20];
1091 struct command *cmd;
1092 const char *refname;
1093 int reflen;
1094
1095 if (linelen < 83 ||
1096 line[40] != ' ' ||
1097 line[81] != ' ' ||
1098 get_sha1_hex(line, old_sha1) ||
1099 get_sha1_hex(line + 41, new_sha1))
1100 die("protocol error: expected old/new/ref, got '%s'", line);
1101
1102 refname = line + 82;
1103 reflen = linelen - 82;
1104 cmd = xcalloc(1, sizeof(struct command) + reflen + 1);
1105 hashcpy(cmd->old_sha1, old_sha1);
1106 hashcpy(cmd->new_sha1, new_sha1);
1107 memcpy(cmd->ref_name, refname, reflen);
1108 cmd->ref_name[reflen] = '\0';
1109 *tail = cmd;
1110 return &cmd->next;
1111 }
1112
1113 static void queue_commands_from_cert(struct command **tail,
1114 struct strbuf *push_cert)
1115 {
1116 const char *boc, *eoc;
1117
1118 if (*tail)
1119 die("protocol error: got both push certificate and unsigned commands");
1120
1121 boc = strstr(push_cert->buf, "\n\n");
1122 if (!boc)
1123 die("malformed push certificate %.*s", 100, push_cert->buf);
1124 else
1125 boc += 2;
1126 eoc = push_cert->buf + parse_signature(push_cert->buf, push_cert->len);
1127
1128 while (boc < eoc) {
1129 const char *eol = memchr(boc, '\n', eoc - boc);
1130 tail = queue_command(tail, boc, eol ? eol - boc : eoc - boc);
1131 boc = eol ? eol + 1 : eoc;
1132 }
1133 }
1134
1135 static struct command *read_head_info(struct sha1_array *shallow)
1136 {
1137 struct command *commands = NULL;
1138 struct command **p = &commands;
1139 for (;;) {
1140 char *line;
1141 int len, linelen;
1142
1143 line = packet_read_line(0, &len);
1144 if (!line)
1145 break;
1146
1147 if (len == 48 && starts_with(line, "shallow ")) {
1148 unsigned char sha1[20];
1149 if (get_sha1_hex(line + 8, sha1))
1150 die("protocol error: expected shallow sha, got '%s'",
1151 line + 8);
1152 sha1_array_append(shallow, sha1);
1153 continue;
1154 }
1155
1156 linelen = strlen(line);
1157 if (linelen < len) {
1158 const char *feature_list = line + linelen + 1;
1159 if (parse_feature_request(feature_list, "report-status"))
1160 report_status = 1;
1161 if (parse_feature_request(feature_list, "side-band-64k"))
1162 use_sideband = LARGE_PACKET_MAX;
1163 if (parse_feature_request(feature_list, "quiet"))
1164 quiet = 1;
1165 }
1166
1167 if (!strcmp(line, "push-cert")) {
1168 int true_flush = 0;
1169 char certbuf[1024];
1170
1171 for (;;) {
1172 len = packet_read(0, NULL, NULL,
1173 certbuf, sizeof(certbuf), 0);
1174 if (!len) {
1175 true_flush = 1;
1176 break;
1177 }
1178 if (!strcmp(certbuf, "push-cert-end\n"))
1179 break; /* end of cert */
1180 strbuf_addstr(&push_cert, certbuf);
1181 }
1182
1183 if (true_flush)
1184 break;
1185 continue;
1186 }
1187
1188 p = queue_command(p, line, linelen);
1189 }
1190
1191 if (push_cert.len)
1192 queue_commands_from_cert(p, &push_cert);
1193
1194 return commands;
1195 }
1196
1197 static const char *parse_pack_header(struct pack_header *hdr)
1198 {
1199 switch (read_pack_header(0, hdr)) {
1200 case PH_ERROR_EOF:
1201 return "eof before pack header was fully read";
1202
1203 case PH_ERROR_PACK_SIGNATURE:
1204 return "protocol error (pack signature mismatch detected)";
1205
1206 case PH_ERROR_PROTOCOL:
1207 return "protocol error (pack version unsupported)";
1208
1209 default:
1210 return "unknown error in parse_pack_header";
1211
1212 case 0:
1213 return NULL;
1214 }
1215 }
1216
1217 static const char *pack_lockfile;
1218
1219 static const char *unpack(int err_fd, struct shallow_info *si)
1220 {
1221 struct pack_header hdr;
1222 struct argv_array av = ARGV_ARRAY_INIT;
1223 const char *hdr_err;
1224 int status;
1225 char hdr_arg[38];
1226 struct child_process child;
1227 int fsck_objects = (receive_fsck_objects >= 0
1228 ? receive_fsck_objects
1229 : transfer_fsck_objects >= 0
1230 ? transfer_fsck_objects
1231 : 0);
1232
1233 hdr_err = parse_pack_header(&hdr);
1234 if (hdr_err) {
1235 if (err_fd > 0)
1236 close(err_fd);
1237 return hdr_err;
1238 }
1239 snprintf(hdr_arg, sizeof(hdr_arg),
1240 "--pack_header=%"PRIu32",%"PRIu32,
1241 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
1242
1243 if (si->nr_ours || si->nr_theirs) {
1244 alt_shallow_file = setup_temporary_shallow(si->shallow);
1245 argv_array_pushl(&av, "--shallow-file", alt_shallow_file, NULL);
1246 }
1247
1248 memset(&child, 0, sizeof(child));
1249 if (ntohl(hdr.hdr_entries) < unpack_limit) {
1250 argv_array_pushl(&av, "unpack-objects", hdr_arg, NULL);
1251 if (quiet)
1252 argv_array_push(&av, "-q");
1253 if (fsck_objects)
1254 argv_array_push(&av, "--strict");
1255 child.argv = av.argv;
1256 child.no_stdout = 1;
1257 child.err = err_fd;
1258 child.git_cmd = 1;
1259 status = run_command(&child);
1260 if (status)
1261 return "unpack-objects abnormal exit";
1262 } else {
1263 int s;
1264 char keep_arg[256];
1265
1266 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
1267 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
1268 strcpy(keep_arg + s, "localhost");
1269
1270 argv_array_pushl(&av, "index-pack",
1271 "--stdin", hdr_arg, keep_arg, NULL);
1272 if (fsck_objects)
1273 argv_array_push(&av, "--strict");
1274 if (fix_thin)
1275 argv_array_push(&av, "--fix-thin");
1276 child.argv = av.argv;
1277 child.out = -1;
1278 child.err = err_fd;
1279 child.git_cmd = 1;
1280 status = start_command(&child);
1281 if (status)
1282 return "index-pack fork failed";
1283 pack_lockfile = index_pack_lockfile(child.out);
1284 close(child.out);
1285 status = finish_command(&child);
1286 if (status)
1287 return "index-pack abnormal exit";
1288 reprepare_packed_git();
1289 }
1290 return NULL;
1291 }
1292
1293 static const char *unpack_with_sideband(struct shallow_info *si)
1294 {
1295 struct async muxer;
1296 const char *ret;
1297
1298 if (!use_sideband)
1299 return unpack(0, si);
1300
1301 memset(&muxer, 0, sizeof(muxer));
1302 muxer.proc = copy_to_sideband;
1303 muxer.in = -1;
1304 if (start_async(&muxer))
1305 return NULL;
1306
1307 ret = unpack(muxer.in, si);
1308
1309 finish_async(&muxer);
1310 return ret;
1311 }
1312
1313 static void prepare_shallow_update(struct command *commands,
1314 struct shallow_info *si)
1315 {
1316 int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1317
1318 si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1319 si->shallow->nr);
1320 assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1321
1322 si->need_reachability_test =
1323 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1324 si->reachable =
1325 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1326 si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1327
1328 for (i = 0; i < si->nr_ours; i++)
1329 si->need_reachability_test[si->ours[i]] = 1;
1330
1331 for (i = 0; i < si->shallow->nr; i++) {
1332 if (!si->used_shallow[i])
1333 continue;
1334 for (j = 0; j < bitmap_size; j++) {
1335 if (!si->used_shallow[i][j])
1336 continue;
1337 si->need_reachability_test[i]++;
1338 for (k = 0; k < 32; k++)
1339 if (si->used_shallow[i][j] & (1 << k))
1340 si->shallow_ref[j * 32 + k]++;
1341 }
1342
1343 /*
1344 * true for those associated with some refs and belong
1345 * in "ours" list aka "step 7 not done yet"
1346 */
1347 si->need_reachability_test[i] =
1348 si->need_reachability_test[i] > 1;
1349 }
1350
1351 /*
1352 * keep hooks happy by forcing a temporary shallow file via
1353 * env variable because we can't add --shallow-file to every
1354 * command. check_everything_connected() will be done with
1355 * true .git/shallow though.
1356 */
1357 setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1358 }
1359
1360 static void update_shallow_info(struct command *commands,
1361 struct shallow_info *si,
1362 struct sha1_array *ref)
1363 {
1364 struct command *cmd;
1365 int *ref_status;
1366 remove_nonexistent_theirs_shallow(si);
1367 if (!si->nr_ours && !si->nr_theirs) {
1368 shallow_update = 0;
1369 return;
1370 }
1371
1372 for (cmd = commands; cmd; cmd = cmd->next) {
1373 if (is_null_sha1(cmd->new_sha1))
1374 continue;
1375 sha1_array_append(ref, cmd->new_sha1);
1376 cmd->index = ref->nr - 1;
1377 }
1378 si->ref = ref;
1379
1380 if (shallow_update) {
1381 prepare_shallow_update(commands, si);
1382 return;
1383 }
1384
1385 ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1386 assign_shallow_commits_to_refs(si, NULL, ref_status);
1387 for (cmd = commands; cmd; cmd = cmd->next) {
1388 if (is_null_sha1(cmd->new_sha1))
1389 continue;
1390 if (ref_status[cmd->index]) {
1391 cmd->error_string = "shallow update not allowed";
1392 cmd->skip_update = 1;
1393 }
1394 }
1395 free(ref_status);
1396 }
1397
1398 static void report(struct command *commands, const char *unpack_status)
1399 {
1400 struct command *cmd;
1401 struct strbuf buf = STRBUF_INIT;
1402
1403 packet_buf_write(&buf, "unpack %s\n",
1404 unpack_status ? unpack_status : "ok");
1405 for (cmd = commands; cmd; cmd = cmd->next) {
1406 if (!cmd->error_string)
1407 packet_buf_write(&buf, "ok %s\n",
1408 cmd->ref_name);
1409 else
1410 packet_buf_write(&buf, "ng %s %s\n",
1411 cmd->ref_name, cmd->error_string);
1412 }
1413 packet_buf_flush(&buf);
1414
1415 if (use_sideband)
1416 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1417 else
1418 write_or_die(1, buf.buf, buf.len);
1419 strbuf_release(&buf);
1420 }
1421
1422 static int delete_only(struct command *commands)
1423 {
1424 struct command *cmd;
1425 for (cmd = commands; cmd; cmd = cmd->next) {
1426 if (!is_null_sha1(cmd->new_sha1))
1427 return 0;
1428 }
1429 return 1;
1430 }
1431
1432 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1433 {
1434 int advertise_refs = 0;
1435 int i;
1436 struct command *commands;
1437 struct sha1_array shallow = SHA1_ARRAY_INIT;
1438 struct sha1_array ref = SHA1_ARRAY_INIT;
1439 struct shallow_info si;
1440
1441 packet_trace_identity("receive-pack");
1442
1443 argv++;
1444 for (i = 1; i < argc; i++) {
1445 const char *arg = *argv++;
1446
1447 if (*arg == '-') {
1448 if (!strcmp(arg, "--quiet")) {
1449 quiet = 1;
1450 continue;
1451 }
1452
1453 if (!strcmp(arg, "--advertise-refs")) {
1454 advertise_refs = 1;
1455 continue;
1456 }
1457 if (!strcmp(arg, "--stateless-rpc")) {
1458 stateless_rpc = 1;
1459 continue;
1460 }
1461 if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1462 fix_thin = 0;
1463 continue;
1464 }
1465
1466 usage(receive_pack_usage);
1467 }
1468 if (service_dir)
1469 usage(receive_pack_usage);
1470 service_dir = arg;
1471 }
1472 if (!service_dir)
1473 usage(receive_pack_usage);
1474
1475 setup_path();
1476
1477 if (!enter_repo(service_dir, 0))
1478 die("'%s' does not appear to be a git repository", service_dir);
1479
1480 git_config(receive_pack_config, NULL);
1481 if (cert_nonce_seed)
1482 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
1483
1484 if (0 <= transfer_unpack_limit)
1485 unpack_limit = transfer_unpack_limit;
1486 else if (0 <= receive_unpack_limit)
1487 unpack_limit = receive_unpack_limit;
1488
1489 if (advertise_refs || !stateless_rpc) {
1490 write_head_info();
1491 }
1492 if (advertise_refs)
1493 return 0;
1494
1495 if ((commands = read_head_info(&shallow)) != NULL) {
1496 const char *unpack_status = NULL;
1497
1498 prepare_shallow_info(&si, &shallow);
1499 if (!si.nr_ours && !si.nr_theirs)
1500 shallow_update = 0;
1501 if (!delete_only(commands)) {
1502 unpack_status = unpack_with_sideband(&si);
1503 update_shallow_info(commands, &si, &ref);
1504 }
1505 execute_commands(commands, unpack_status, &si);
1506 if (pack_lockfile)
1507 unlink_or_warn(pack_lockfile);
1508 if (report_status)
1509 report(commands, unpack_status);
1510 run_receive_hook(commands, "post-receive", 1);
1511 run_update_post_hook(commands);
1512 if (auto_gc) {
1513 const char *argv_gc_auto[] = {
1514 "gc", "--auto", "--quiet", NULL,
1515 };
1516 int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1517 run_command_v_opt(argv_gc_auto, opt);
1518 }
1519 if (auto_update_server_info)
1520 update_server_info(0);
1521 clear_shallow_info(&si);
1522 }
1523 if (use_sideband)
1524 packet_flush(1);
1525 sha1_array_clear(&shallow);
1526 sha1_array_clear(&ref);
1527 free((void *)push_cert_nonce);
1528 return 0;
1529 }