?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Git 2.34.8
[git.git] / builtin / receive-pack.c
blob49b846d960522ad1a5f29f7394bca4fa24e5b622
1 #include "builtin.h"
2 #include "repository.h"
3 #include "config.h"
4 #include "lockfile.h"
5 #include "pack.h"
6 #include "refs.h"
7 #include "pkt-line.h"
8 #include "sideband.h"
9 #include "run-command.h"
10 #include "hook.h"
11 #include "exec-cmd.h"
12 #include "commit.h"
13 #include "object.h"
14 #include "remote.h"
15 #include "connect.h"
16 #include "string-list.h"
17 #include "oid-array.h"
18 #include "connected.h"
19 #include "strvec.h"
20 #include "version.h"
21 #include "tag.h"
22 #include "gpg-interface.h"
23 #include "sigchain.h"
24 #include "fsck.h"
25 #include "tmp-objdir.h"
26 #include "oidset.h"
27 #include "packfile.h"
28 #include "object-store.h"
29 #include "protocol.h"
30 #include "commit-reach.h"
31 #include "worktree.h"
32 #include "shallow.h"
33
34 static const char * const receive_pack_usage[] = {
35 N_("git receive-pack <git-dir>"),
36 NULL
37 };
38
39 enum deny_action {
40 DENY_UNCONFIGURED,
41 DENY_IGNORE,
42 DENY_WARN,
43 DENY_REFUSE,
44 DENY_UPDATE_INSTEAD
45 };
46
47 static int deny_deletes;
48 static int deny_non_fast_forwards;
49 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
50 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
51 static int receive_fsck_objects = -1;
52 static int transfer_fsck_objects = -1;
53 static struct strbuf fsck_msg_types = STRBUF_INIT;
54 static int receive_unpack_limit = -1;
55 static int transfer_unpack_limit = -1;
56 static int advertise_atomic_push = 1;
57 static int advertise_push_options;
58 static int advertise_sid;
59 static int unpack_limit = 100;
60 static off_t max_input_size;
61 static int report_status;
62 static int report_status_v2;
63 static int use_sideband;
64 static int use_atomic;
65 static int use_push_options;
66 static int quiet;
67 static int prefer_ofs_delta = 1;
68 static int auto_update_server_info;
69 static int auto_gc = 1;
70 static int reject_thin;
71 static int stateless_rpc;
72 static const char *service_dir;
73 static const char *head_name;
74 static void *head_name_to_free;
75 static int sent_capabilities;
76 static int shallow_update;
77 static const char *alt_shallow_file;
78 static struct strbuf push_cert = STRBUF_INIT;
79 static struct object_id push_cert_oid;
80 static struct signature_check sigcheck;
81 static const char *push_cert_nonce;
82 static const char *cert_nonce_seed;
83
84 static const char *NONCE_UNSOLICITED = "UNSOLICITED";
85 static const char *NONCE_BAD = "BAD";
86 static const char *NONCE_MISSING = "MISSING";
87 static const char *NONCE_OK = "OK";
88 static const char *NONCE_SLOP = "SLOP";
89 static const char *nonce_status;
90 static long nonce_stamp_slop;
91 static timestamp_t nonce_stamp_slop_limit;
92 static struct ref_transaction *transaction;
93
94 static enum {
95 KEEPALIVE_NEVER = 0,
96 KEEPALIVE_AFTER_NUL,
97 KEEPALIVE_ALWAYS
98 } use_keepalive;
99 static int keepalive_in_sec = 5;
100
101 static struct tmp_objdir *tmp_objdir;
102
103 static struct proc_receive_ref {
104 unsigned int want_add:1,
105 want_delete:1,
106 want_modify:1,
107 negative_ref:1;
108 char *ref_prefix;
109 struct proc_receive_ref *next;
110 } *proc_receive_ref;
111
112 static void proc_receive_ref_append(const char *prefix);
113
114 static enum deny_action parse_deny_action(const char *var, const char *value)
115 {
116 if (value) {
117 if (!strcasecmp(value, "ignore"))
118 return DENY_IGNORE;
119 if (!strcasecmp(value, "warn"))
120 return DENY_WARN;
121 if (!strcasecmp(value, "refuse"))
122 return DENY_REFUSE;
123 if (!strcasecmp(value, "updateinstead"))
124 return DENY_UPDATE_INSTEAD;
125 }
126 if (git_config_bool(var, value))
127 return DENY_REFUSE;
128 return DENY_IGNORE;
129 }
130
131 static int receive_pack_config(const char *var, const char *value, void *cb)
132 {
133 int status = parse_hide_refs_config(var, value, "receive");
134
135 if (status)
136 return status;
137
138 status = git_gpg_config(var, value, NULL);
139 if (status)
140 return status;
141
142 if (strcmp(var, "receive.denydeletes") == 0) {
143 deny_deletes = git_config_bool(var, value);
144 return 0;
145 }
146
147 if (strcmp(var, "receive.denynonfastforwards") == 0) {
148 deny_non_fast_forwards = git_config_bool(var, value);
149 return 0;
150 }
151
152 if (strcmp(var, "receive.unpacklimit") == 0) {
153 receive_unpack_limit = git_config_int(var, value);
154 return 0;
155 }
156
157 if (strcmp(var, "transfer.unpacklimit") == 0) {
158 transfer_unpack_limit = git_config_int(var, value);
159 return 0;
160 }
161
162 if (strcmp(var, "receive.fsck.skiplist") == 0) {
163 const char *path;
164
165 if (git_config_pathname(&path, var, value))
166 return 1;
167 strbuf_addf(&fsck_msg_types, "%cskiplist=%s",
168 fsck_msg_types.len ? ',' : '=', path);
169 free((char *)path);
170 return 0;
171 }
172
173 if (skip_prefix(var, "receive.fsck.", &var)) {
174 if (is_valid_msg_type(var, value))
175 strbuf_addf(&fsck_msg_types, "%c%s=%s",
176 fsck_msg_types.len ? ',' : '=', var, value);
177 else
178 warning("Skipping unknown msg id '%s'", var);
179 return 0;
180 }
181
182 if (strcmp(var, "receive.fsckobjects") == 0) {
183 receive_fsck_objects = git_config_bool(var, value);
184 return 0;
185 }
186
187 if (strcmp(var, "transfer.fsckobjects") == 0) {
188 transfer_fsck_objects = git_config_bool(var, value);
189 return 0;
190 }
191
192 if (!strcmp(var, "receive.denycurrentbranch")) {
193 deny_current_branch = parse_deny_action(var, value);
194 return 0;
195 }
196
197 if (strcmp(var, "receive.denydeletecurrent") == 0) {
198 deny_delete_current = parse_deny_action(var, value);
199 return 0;
200 }
201
202 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
203 prefer_ofs_delta = git_config_bool(var, value);
204 return 0;
205 }
206
207 if (strcmp(var, "receive.updateserverinfo") == 0) {
208 auto_update_server_info = git_config_bool(var, value);
209 return 0;
210 }
211
212 if (strcmp(var, "receive.autogc") == 0) {
213 auto_gc = git_config_bool(var, value);
214 return 0;
215 }
216
217 if (strcmp(var, "receive.shallowupdate") == 0) {
218 shallow_update = git_config_bool(var, value);
219 return 0;
220 }
221
222 if (strcmp(var, "receive.certnonceseed") == 0)
223 return git_config_string(&cert_nonce_seed, var, value);
224
225 if (strcmp(var, "receive.certnonceslop") == 0) {
226 nonce_stamp_slop_limit = git_config_ulong(var, value);
227 return 0;
228 }
229
230 if (strcmp(var, "receive.advertiseatomic") == 0) {
231 advertise_atomic_push = git_config_bool(var, value);
232 return 0;
233 }
234
235 if (strcmp(var, "receive.advertisepushoptions") == 0) {
236 advertise_push_options = git_config_bool(var, value);
237 return 0;
238 }
239
240 if (strcmp(var, "receive.keepalive") == 0) {
241 keepalive_in_sec = git_config_int(var, value);
242 return 0;
243 }
244
245 if (strcmp(var, "receive.maxinputsize") == 0) {
246 max_input_size = git_config_int64(var, value);
247 return 0;
248 }
249
250 if (strcmp(var, "receive.procreceiverefs") == 0) {
251 if (!value)
252 return config_error_nonbool(var);
253 proc_receive_ref_append(value);
254 return 0;
255 }
256
257 if (strcmp(var, "transfer.advertisesid") == 0) {
258 advertise_sid = git_config_bool(var, value);
259 return 0;
260 }
261
262 return git_default_config(var, value, cb);
263 }
264
265 static void show_ref(const char *path, const struct object_id *oid)
266 {
267 if (sent_capabilities) {
268 packet_write_fmt(1, "%s %s\n", oid_to_hex(oid), path);
269 } else {
270 struct strbuf cap = STRBUF_INIT;
271
272 strbuf_addstr(&cap,
273 "report-status report-status-v2 delete-refs side-band-64k quiet");
274 if (advertise_atomic_push)
275 strbuf_addstr(&cap, " atomic");
276 if (prefer_ofs_delta)
277 strbuf_addstr(&cap, " ofs-delta");
278 if (push_cert_nonce)
279 strbuf_addf(&cap, " push-cert=%s", push_cert_nonce);
280 if (advertise_push_options)
281 strbuf_addstr(&cap, " push-options");
282 if (advertise_sid)
283 strbuf_addf(&cap, " session-id=%s", trace2_session_id());
284 strbuf_addf(&cap, " object-format=%s", the_hash_algo->name);
285 strbuf_addf(&cap, " agent=%s", git_user_agent_sanitized());
286 packet_write_fmt(1, "%s %s%c%s\n",
287 oid_to_hex(oid), path, 0, cap.buf);
288 strbuf_release(&cap);
289 sent_capabilities = 1;
290 }
291 }
292
293 static int show_ref_cb(const char *path_full, const struct object_id *oid,
294 int flag, void *data)
295 {
296 struct oidset *seen = data;
297 const char *path = strip_namespace(path_full);
298
299 if (ref_is_hidden(path, path_full))
300 return 0;
301
302 /*
303 * Advertise refs outside our current namespace as ".have"
304 * refs, so that the client can use them to minimize data
305 * transfer but will otherwise ignore them.
306 */
307 if (!path) {
308 if (oidset_insert(seen, oid))
309 return 0;
310 path = ".have";
311 } else {
312 oidset_insert(seen, oid);
313 }
314 show_ref(path, oid);
315 return 0;
316 }
317
318 static void show_one_alternate_ref(const struct object_id *oid,
319 void *data)
320 {
321 struct oidset *seen = data;
322
323 if (oidset_insert(seen, oid))
324 return;
325
326 show_ref(".have", oid);
327 }
328
329 static void write_head_info(void)
330 {
331 static struct oidset seen = OIDSET_INIT;
332
333 for_each_ref(show_ref_cb, &seen);
334 for_each_alternate_ref(show_one_alternate_ref, &seen);
335 oidset_clear(&seen);
336 if (!sent_capabilities)
337 show_ref("capabilities^{}", null_oid());
338
339 advertise_shallow_grafts(1);
340
341 /* EOF */
342 packet_flush(1);
343 }
344
345 #define RUN_PROC_RECEIVE_SCHEDULED 1
346 #define RUN_PROC_RECEIVE_RETURNED 2
347 struct command {
348 struct command *next;
349 const char *error_string;
350 struct ref_push_report *report;
351 unsigned int skip_update:1,
352 did_not_exist:1,
353 run_proc_receive:2;
354 int index;
355 struct object_id old_oid;
356 struct object_id new_oid;
357 char ref_name[FLEX_ARRAY]; /* more */
358 };
359
360 static void proc_receive_ref_append(const char *prefix)
361 {
362 struct proc_receive_ref *ref_pattern;
363 char *p;
364 int len;
365
366 CALLOC_ARRAY(ref_pattern, 1);
367 p = strchr(prefix, ':');
368 if (p) {
369 while (prefix < p) {
370 if (*prefix == 'a')
371 ref_pattern->want_add = 1;
372 else if (*prefix == 'd')
373 ref_pattern->want_delete = 1;
374 else if (*prefix == 'm')
375 ref_pattern->want_modify = 1;
376 else if (*prefix == '!')
377 ref_pattern->negative_ref = 1;
378 prefix++;
379 }
380 prefix++;
381 } else {
382 ref_pattern->want_add = 1;
383 ref_pattern->want_delete = 1;
384 ref_pattern->want_modify = 1;
385 }
386 len = strlen(prefix);
387 while (len && prefix[len - 1] == '/')
388 len--;
389 ref_pattern->ref_prefix = xmemdupz(prefix, len);
390 if (!proc_receive_ref) {
391 proc_receive_ref = ref_pattern;
392 } else {
393 struct proc_receive_ref *end;
394
395 end = proc_receive_ref;
396 while (end->next)
397 end = end->next;
398 end->next = ref_pattern;
399 }
400 }
401
402 static int proc_receive_ref_matches(struct command *cmd)
403 {
404 struct proc_receive_ref *p;
405
406 if (!proc_receive_ref)
407 return 0;
408
409 for (p = proc_receive_ref; p; p = p->next) {
410 const char *match = p->ref_prefix;
411 const char *remains;
412
413 if (!p->want_add && is_null_oid(&cmd->old_oid))
414 continue;
415 else if (!p->want_delete && is_null_oid(&cmd->new_oid))
416 continue;
417 else if (!p->want_modify &&
418 !is_null_oid(&cmd->old_oid) &&
419 !is_null_oid(&cmd->new_oid))
420 continue;
421
422 if (skip_prefix(cmd->ref_name, match, &remains) &&
423 (!*remains || *remains == '/')) {
424 if (!p->negative_ref)
425 return 1;
426 } else if (p->negative_ref) {
427 return 1;
428 }
429 }
430 return 0;
431 }
432
433 static void report_message(const char *prefix, const char *err, va_list params)
434 {
435 int sz;
436 char msg[4096];
437
438 sz = xsnprintf(msg, sizeof(msg), "%s", prefix);
439 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
440 if (sz > (sizeof(msg) - 1))
441 sz = sizeof(msg) - 1;
442 msg[sz++] = '\n';
443
444 if (use_sideband)
445 send_sideband(1, 2, msg, sz, use_sideband);
446 else
447 xwrite(2, msg, sz);
448 }
449
450 __attribute__((format (printf, 1, 2)))
451 static void rp_warning(const char *err, ...)
452 {
453 va_list params;
454 va_start(params, err);
455 report_message("warning: ", err, params);
456 va_end(params);
457 }
458
459 __attribute__((format (printf, 1, 2)))
460 static void rp_error(const char *err, ...)
461 {
462 va_list params;
463 va_start(params, err);
464 report_message("error: ", err, params);
465 va_end(params);
466 }
467
468 static int copy_to_sideband(int in, int out, void *arg)
469 {
470 char data[128];
471 int keepalive_active = 0;
472
473 if (keepalive_in_sec <= 0)
474 use_keepalive = KEEPALIVE_NEVER;
475 if (use_keepalive == KEEPALIVE_ALWAYS)
476 keepalive_active = 1;
477
478 while (1) {
479 ssize_t sz;
480
481 if (keepalive_active) {
482 struct pollfd pfd;
483 int ret;
484
485 pfd.fd = in;
486 pfd.events = POLLIN;
487 ret = poll(&pfd, 1, 1000 * keepalive_in_sec);
488
489 if (ret < 0) {
490 if (errno == EINTR)
491 continue;
492 else
493 break;
494 } else if (ret == 0) {
495 /* no data; send a keepalive packet */
496 static const char buf[] = "0005\1";
497 write_or_die(1, buf, sizeof(buf) - 1);
498 continue;
499 } /* else there is actual data to read */
500 }
501
502 sz = xread(in, data, sizeof(data));
503 if (sz <= 0)
504 break;
505
506 if (use_keepalive == KEEPALIVE_AFTER_NUL && !keepalive_active) {
507 const char *p = memchr(data, '\0', sz);
508 if (p) {
509 /*
510 * The NUL tells us to start sending keepalives. Make
511 * sure we send any other data we read along
512 * with it.
513 */
514 keepalive_active = 1;
515 send_sideband(1, 2, data, p - data, use_sideband);
516 send_sideband(1, 2, p + 1, sz - (p - data + 1), use_sideband);
517 continue;
518 }
519 }
520
521 /*
522 * Either we're not looking for a NUL signal, or we didn't see
523 * it yet; just pass along the data.
524 */
525 send_sideband(1, 2, data, sz, use_sideband);
526 }
527 close(in);
528 return 0;
529 }
530
531 static void hmac_hash(unsigned char *out,
532 const char *key_in, size_t key_len,
533 const char *text, size_t text_len)
534 {
535 unsigned char key[GIT_MAX_BLKSZ];
536 unsigned char k_ipad[GIT_MAX_BLKSZ];
537 unsigned char k_opad[GIT_MAX_BLKSZ];
538 int i;
539 git_hash_ctx ctx;
540
541 /* RFC 2104 2. (1) */
542 memset(key, '\0', GIT_MAX_BLKSZ);
543 if (the_hash_algo->blksz < key_len) {
544 the_hash_algo->init_fn(&ctx);
545 the_hash_algo->update_fn(&ctx, key_in, key_len);
546 the_hash_algo->final_fn(key, &ctx);
547 } else {
548 memcpy(key, key_in, key_len);
549 }
550
551 /* RFC 2104 2. (2) & (5) */
552 for (i = 0; i < sizeof(key); i++) {
553 k_ipad[i] = key[i] ^ 0x36;
554 k_opad[i] = key[i] ^ 0x5c;
555 }
556
557 /* RFC 2104 2. (3) & (4) */
558 the_hash_algo->init_fn(&ctx);
559 the_hash_algo->update_fn(&ctx, k_ipad, sizeof(k_ipad));
560 the_hash_algo->update_fn(&ctx, text, text_len);
561 the_hash_algo->final_fn(out, &ctx);
562
563 /* RFC 2104 2. (6) & (7) */
564 the_hash_algo->init_fn(&ctx);
565 the_hash_algo->update_fn(&ctx, k_opad, sizeof(k_opad));
566 the_hash_algo->update_fn(&ctx, out, the_hash_algo->rawsz);
567 the_hash_algo->final_fn(out, &ctx);
568 }
569
570 static char *prepare_push_cert_nonce(const char *path, timestamp_t stamp)
571 {
572 struct strbuf buf = STRBUF_INIT;
573 unsigned char hash[GIT_MAX_RAWSZ];
574
575 strbuf_addf(&buf, "%s:%"PRItime, path, stamp);
576 hmac_hash(hash, buf.buf, buf.len, cert_nonce_seed, strlen(cert_nonce_seed));
577 strbuf_release(&buf);
578
579 /* RFC 2104 5. HMAC-SHA1 or HMAC-SHA256 */
580 strbuf_addf(&buf, "%"PRItime"-%.*s", stamp, (int)the_hash_algo->hexsz, hash_to_hex(hash));
581 return strbuf_detach(&buf, NULL);
582 }
583
584 /*
585 * NEEDSWORK: reuse find_commit_header() from jk/commit-author-parsing
586 * after dropping "_commit" from its name and possibly moving it out
587 * of commit.c
588 */
589 static char *find_header(const char *msg, size_t len, const char *key,
590 const char **next_line)
591 {
592 int key_len = strlen(key);
593 const char *line = msg;
594
595 while (line && line < msg + len) {
596 const char *eol = strchrnul(line, '\n');
597
598 if ((msg + len <= eol) || line == eol)
599 return NULL;
600 if (line + key_len < eol &&
601 !memcmp(line, key, key_len) && line[key_len] == ' ') {
602 int offset = key_len + 1;
603 if (next_line)
604 *next_line = *eol ? eol + 1 : eol;
605 return xmemdupz(line + offset, (eol - line) - offset);
606 }
607 line = *eol ? eol + 1 : NULL;
608 }
609 return NULL;
610 }
611
612 /*
613 * Return zero if a and b are equal up to n bytes and nonzero if they are not.
614 * This operation is guaranteed to run in constant time to avoid leaking data.
615 */
616 static int constant_memequal(const char *a, const char *b, size_t n)
617 {
618 int res = 0;
619 size_t i;
620
621 for (i = 0; i < n; i++)
622 res |= a[i] ^ b[i];
623 return res;
624 }
625
626 static const char *check_nonce(const char *buf, size_t len)
627 {
628 char *nonce = find_header(buf, len, "nonce", NULL);
629 timestamp_t stamp, ostamp;
630 char *bohmac, *expect = NULL;
631 const char *retval = NONCE_BAD;
632 size_t noncelen;
633
634 if (!nonce) {
635 retval = NONCE_MISSING;
636 goto leave;
637 } else if (!push_cert_nonce) {
638 retval = NONCE_UNSOLICITED;
639 goto leave;
640 } else if (!strcmp(push_cert_nonce, nonce)) {
641 retval = NONCE_OK;
642 goto leave;
643 }
644
645 if (!stateless_rpc) {
646 /* returned nonce MUST match what we gave out earlier */
647 retval = NONCE_BAD;
648 goto leave;
649 }
650
651 /*
652 * In stateless mode, we may be receiving a nonce issued by
653 * another instance of the server that serving the same
654 * repository, and the timestamps may not match, but the
655 * nonce-seed and dir should match, so we can recompute and
656 * report the time slop.
657 *
658 * In addition, when a nonce issued by another instance has
659 * timestamp within receive.certnonceslop seconds, we pretend
660 * as if we issued that nonce when reporting to the hook.
661 */
662
663 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
664 if (*nonce <= '0' || '9' < *nonce) {
665 retval = NONCE_BAD;
666 goto leave;
667 }
668 stamp = parse_timestamp(nonce, &bohmac, 10);
669 if (bohmac == nonce || bohmac[0] != '-') {
670 retval = NONCE_BAD;
671 goto leave;
672 }
673
674 noncelen = strlen(nonce);
675 expect = prepare_push_cert_nonce(service_dir, stamp);
676 if (noncelen != strlen(expect)) {
677 /* This is not even the right size. */
678 retval = NONCE_BAD;
679 goto leave;
680 }
681 if (constant_memequal(expect, nonce, noncelen)) {
682 /* Not what we would have signed earlier */
683 retval = NONCE_BAD;
684 goto leave;
685 }
686
687 /*
688 * By how many seconds is this nonce stale? Negative value
689 * would mean it was issued by another server with its clock
690 * skewed in the future.
691 */
692 ostamp = parse_timestamp(push_cert_nonce, NULL, 10);
693 nonce_stamp_slop = (long)ostamp - (long)stamp;
694
695 if (nonce_stamp_slop_limit &&
696 labs(nonce_stamp_slop) <= nonce_stamp_slop_limit) {
697 /*
698 * Pretend as if the received nonce (which passes the
699 * HMAC check, so it is not a forged by third-party)
700 * is what we issued.
701 */
702 free((void *)push_cert_nonce);
703 push_cert_nonce = xstrdup(nonce);
704 retval = NONCE_OK;
705 } else {
706 retval = NONCE_SLOP;
707 }
708
709 leave:
710 free(nonce);
711 free(expect);
712 return retval;
713 }
714
715 /*
716 * Return 1 if there is no push_cert or if the push options in push_cert are
717 * the same as those in the argument; 0 otherwise.
718 */
719 static int check_cert_push_options(const struct string_list *push_options)
720 {
721 const char *buf = push_cert.buf;
722 int len = push_cert.len;
723
724 char *option;
725 const char *next_line;
726 int options_seen = 0;
727
728 int retval = 1;
729
730 if (!len)
731 return 1;
732
733 while ((option = find_header(buf, len, "push-option", &next_line))) {
734 len -= (next_line - buf);
735 buf = next_line;
736 options_seen++;
737 if (options_seen > push_options->nr
738 || strcmp(option,
739 push_options->items[options_seen - 1].string)) {
740 retval = 0;
741 goto leave;
742 }
743 free(option);
744 }
745
746 if (options_seen != push_options->nr)
747 retval = 0;
748
749 leave:
750 free(option);
751 return retval;
752 }
753
754 static void prepare_push_cert_sha1(struct child_process *proc)
755 {
756 static int already_done;
757
758 if (!push_cert.len)
759 return;
760
761 if (!already_done) {
762 int bogs /* beginning_of_gpg_sig */;
763
764 already_done = 1;
765 if (write_object_file(push_cert.buf, push_cert.len, "blob",
766 &push_cert_oid))
767 oidclr(&push_cert_oid);
768
769 memset(&sigcheck, '\0', sizeof(sigcheck));
770
771 bogs = parse_signed_buffer(push_cert.buf, push_cert.len);
772 check_signature(push_cert.buf, bogs, push_cert.buf + bogs,
773 push_cert.len - bogs, &sigcheck);
774
775 nonce_status = check_nonce(push_cert.buf, bogs);
776 }
777 if (!is_null_oid(&push_cert_oid)) {
778 strvec_pushf(&proc->env_array, "GIT_PUSH_CERT=%s",
779 oid_to_hex(&push_cert_oid));
780 strvec_pushf(&proc->env_array, "GIT_PUSH_CERT_SIGNER=%s",
781 sigcheck.signer ? sigcheck.signer : "");
782 strvec_pushf(&proc->env_array, "GIT_PUSH_CERT_KEY=%s",
783 sigcheck.key ? sigcheck.key : "");
784 strvec_pushf(&proc->env_array, "GIT_PUSH_CERT_STATUS=%c",
785 sigcheck.result);
786 if (push_cert_nonce) {
787 strvec_pushf(&proc->env_array,
788 "GIT_PUSH_CERT_NONCE=%s",
789 push_cert_nonce);
790 strvec_pushf(&proc->env_array,
791 "GIT_PUSH_CERT_NONCE_STATUS=%s",
792 nonce_status);
793 if (nonce_status == NONCE_SLOP)
794 strvec_pushf(&proc->env_array,
795 "GIT_PUSH_CERT_NONCE_SLOP=%ld",
796 nonce_stamp_slop);
797 }
798 }
799 }
800
801 struct receive_hook_feed_state {
802 struct command *cmd;
803 struct ref_push_report *report;
804 int skip_broken;
805 struct strbuf buf;
806 const struct string_list *push_options;
807 };
808
809 typedef int (*feed_fn)(void *, const char **, size_t *);
810 static int run_and_feed_hook(const char *hook_name, feed_fn feed,
811 struct receive_hook_feed_state *feed_state)
812 {
813 struct child_process proc = CHILD_PROCESS_INIT;
814 struct async muxer;
815 const char *argv[2];
816 int code;
817
818 argv[0] = find_hook(hook_name);
819 if (!argv[0])
820 return 0;
821
822 argv[1] = NULL;
823
824 proc.argv = argv;
825 proc.in = -1;
826 proc.stdout_to_stderr = 1;
827 proc.trace2_hook_name = hook_name;
828
829 if (feed_state->push_options) {
830 int i;
831 for (i = 0; i < feed_state->push_options->nr; i++)
832 strvec_pushf(&proc.env_array,
833 "GIT_PUSH_OPTION_%d=%s", i,
834 feed_state->push_options->items[i].string);
835 strvec_pushf(&proc.env_array, "GIT_PUSH_OPTION_COUNT=%d",
836 feed_state->push_options->nr);
837 } else
838 strvec_pushf(&proc.env_array, "GIT_PUSH_OPTION_COUNT");
839
840 if (tmp_objdir)
841 strvec_pushv(&proc.env_array, tmp_objdir_env(tmp_objdir));
842
843 if (use_sideband) {
844 memset(&muxer, 0, sizeof(muxer));
845 muxer.proc = copy_to_sideband;
846 muxer.in = -1;
847 code = start_async(&muxer);
848 if (code)
849 return code;
850 proc.err = muxer.in;
851 }
852
853 prepare_push_cert_sha1(&proc);
854
855 code = start_command(&proc);
856 if (code) {
857 if (use_sideband)
858 finish_async(&muxer);
859 return code;
860 }
861
862 sigchain_push(SIGPIPE, SIG_IGN);
863
864 while (1) {
865 const char *buf;
866 size_t n;
867 if (feed(feed_state, &buf, &n))
868 break;
869 if (write_in_full(proc.in, buf, n) < 0)
870 break;
871 }
872 close(proc.in);
873 if (use_sideband)
874 finish_async(&muxer);
875
876 sigchain_pop(SIGPIPE);
877
878 return finish_command(&proc);
879 }
880
881 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
882 {
883 struct receive_hook_feed_state *state = state_;
884 struct command *cmd = state->cmd;
885
886 while (cmd &&
887 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
888 cmd = cmd->next;
889 if (!cmd)
890 return -1; /* EOF */
891 if (!bufp)
892 return 0; /* OK, can feed something. */
893 strbuf_reset(&state->buf);
894 if (!state->report)
895 state->report = cmd->report;
896 if (state->report) {
897 struct object_id *old_oid;
898 struct object_id *new_oid;
899 const char *ref_name;
900
901 old_oid = state->report->old_oid ? state->report->old_oid : &cmd->old_oid;
902 new_oid = state->report->new_oid ? state->report->new_oid : &cmd->new_oid;
903 ref_name = state->report->ref_name ? state->report->ref_name : cmd->ref_name;
904 strbuf_addf(&state->buf, "%s %s %s\n",
905 oid_to_hex(old_oid), oid_to_hex(new_oid),
906 ref_name);
907 state->report = state->report->next;
908 if (!state->report)
909 state->cmd = cmd->next;
910 } else {
911 strbuf_addf(&state->buf, "%s %s %s\n",
912 oid_to_hex(&cmd->old_oid), oid_to_hex(&cmd->new_oid),
913 cmd->ref_name);
914 state->cmd = cmd->next;
915 }
916 if (bufp) {
917 *bufp = state->buf.buf;
918 *sizep = state->buf.len;
919 }
920 return 0;
921 }
922
923 static int run_receive_hook(struct command *commands,
924 const char *hook_name,
925 int skip_broken,
926 const struct string_list *push_options)
927 {
928 struct receive_hook_feed_state state;
929 int status;
930
931 strbuf_init(&state.buf, 0);
932 state.cmd = commands;
933 state.skip_broken = skip_broken;
934 state.report = NULL;
935 if (feed_receive_hook(&state, NULL, NULL))
936 return 0;
937 state.cmd = commands;
938 state.push_options = push_options;
939 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
940 strbuf_release(&state.buf);
941 return status;
942 }
943
944 static int run_update_hook(struct command *cmd)
945 {
946 const char *argv[5];
947 struct child_process proc = CHILD_PROCESS_INIT;
948 int code;
949
950 argv[0] = find_hook("update");
951 if (!argv[0])
952 return 0;
953
954 argv[1] = cmd->ref_name;
955 argv[2] = oid_to_hex(&cmd->old_oid);
956 argv[3] = oid_to_hex(&cmd->new_oid);
957 argv[4] = NULL;
958
959 proc.no_stdin = 1;
960 proc.stdout_to_stderr = 1;
961 proc.err = use_sideband ? -1 : 0;
962 proc.argv = argv;
963 proc.trace2_hook_name = "update";
964
965 code = start_command(&proc);
966 if (code)
967 return code;
968 if (use_sideband)
969 copy_to_sideband(proc.err, -1, NULL);
970 return finish_command(&proc);
971 }
972
973 static struct command *find_command_by_refname(struct command *list,
974 const char *refname)
975 {
976 for (; list; list = list->next)
977 if (!strcmp(list->ref_name, refname))
978 return list;
979 return NULL;
980 }
981
982 static int read_proc_receive_report(struct packet_reader *reader,
983 struct command *commands,
984 struct strbuf *errmsg)
985 {
986 struct command *cmd;
987 struct command *hint = NULL;
988 struct ref_push_report *report = NULL;
989 int new_report = 0;
990 int code = 0;
991 int once = 0;
992 int response = 0;
993
994 for (;;) {
995 struct object_id old_oid, new_oid;
996 const char *head;
997 const char *refname;
998 char *p;
999 enum packet_read_status status;
1000
1001 status = packet_reader_read(reader);
1002 if (status != PACKET_READ_NORMAL) {
1003 /* Check whether proc-receive exited abnormally */
1004 if (status == PACKET_READ_EOF && !response) {
1005 strbuf_addstr(errmsg, "proc-receive exited abnormally");
1006 return -1;
1007 }
1008 break;
1009 }
1010 response++;
1011
1012 head = reader->line;
1013 p = strchr(head, ' ');
1014 if (!p) {
1015 strbuf_addf(errmsg, "proc-receive reported incomplete status line: '%s'\n", head);
1016 code = -1;
1017 continue;
1018 }
1019 *p++ = '\0';
1020 if (!strcmp(head, "option")) {
1021 const char *key, *val;
1022
1023 if (!hint || !(report || new_report)) {
1024 if (!once++)
1025 strbuf_addstr(errmsg, "proc-receive reported 'option' without a matching 'ok/ng' directive\n");
1026 code = -1;
1027 continue;
1028 }
1029 if (new_report) {
1030 if (!hint->report) {
1031 CALLOC_ARRAY(hint->report, 1);
1032 report = hint->report;
1033 } else {
1034 report = hint->report;
1035 while (report->next)
1036 report = report->next;
1037 report->next = xcalloc(1, sizeof(struct ref_push_report));
1038 report = report->next;
1039 }
1040 new_report = 0;
1041 }
1042 key = p;
1043 p = strchr(key, ' ');
1044 if (p)
1045 *p++ = '\0';
1046 val = p;
1047 if (!strcmp(key, "refname"))
1048 report->ref_name = xstrdup_or_null(val);
1049 else if (!strcmp(key, "old-oid") && val &&
1050 !parse_oid_hex(val, &old_oid, &val))
1051 report->old_oid = oiddup(&old_oid);
1052 else if (!strcmp(key, "new-oid") && val &&
1053 !parse_oid_hex(val, &new_oid, &val))
1054 report->new_oid = oiddup(&new_oid);
1055 else if (!strcmp(key, "forced-update"))
1056 report->forced_update = 1;
1057 else if (!strcmp(key, "fall-through"))
1058 /* Fall through, let 'receive-pack' to execute it. */
1059 hint->run_proc_receive = 0;
1060 continue;
1061 }
1062
1063 report = NULL;
1064 new_report = 0;
1065 refname = p;
1066 p = strchr(refname, ' ');
1067 if (p)
1068 *p++ = '\0';
1069 if (strcmp(head, "ok") && strcmp(head, "ng")) {
1070 strbuf_addf(errmsg, "proc-receive reported bad status '%s' on ref '%s'\n",
1071 head, refname);
1072 code = -1;
1073 continue;
1074 }
1075
1076 /* first try searching at our hint, falling back to all refs */
1077 if (hint)
1078 hint = find_command_by_refname(hint, refname);
1079 if (!hint)
1080 hint = find_command_by_refname(commands, refname);
1081 if (!hint) {
1082 strbuf_addf(errmsg, "proc-receive reported status on unknown ref: %s\n",
1083 refname);
1084 code = -1;
1085 continue;
1086 }
1087 if (!hint->run_proc_receive) {
1088 strbuf_addf(errmsg, "proc-receive reported status on unexpected ref: %s\n",
1089 refname);
1090 code = -1;
1091 continue;
1092 }
1093 hint->run_proc_receive |= RUN_PROC_RECEIVE_RETURNED;
1094 if (!strcmp(head, "ng")) {
1095 if (p)
1096 hint->error_string = xstrdup(p);
1097 else
1098 hint->error_string = "failed";
1099 code = -1;
1100 continue;
1101 }
1102 new_report = 1;
1103 }
1104
1105 for (cmd = commands; cmd; cmd = cmd->next)
1106 if (cmd->run_proc_receive && !cmd->error_string &&
1107 !(cmd->run_proc_receive & RUN_PROC_RECEIVE_RETURNED)) {
1108 cmd->error_string = "proc-receive failed to report status";
1109 code = -1;
1110 }
1111 return code;
1112 }
1113
1114 static int run_proc_receive_hook(struct command *commands,
1115 const struct string_list *push_options)
1116 {
1117 struct child_process proc = CHILD_PROCESS_INIT;
1118 struct async muxer;
1119 struct command *cmd;
1120 const char *argv[2];
1121 struct packet_reader reader;
1122 struct strbuf cap = STRBUF_INIT;
1123 struct strbuf errmsg = STRBUF_INIT;
1124 int hook_use_push_options = 0;
1125 int version = 0;
1126 int code;
1127
1128 argv[0] = find_hook("proc-receive");
1129 if (!argv[0]) {
1130 rp_error("cannot find hook 'proc-receive'");
1131 return -1;
1132 }
1133 argv[1] = NULL;
1134
1135 proc.argv = argv;
1136 proc.in = -1;
1137 proc.out = -1;
1138 proc.trace2_hook_name = "proc-receive";
1139
1140 if (use_sideband) {
1141 memset(&muxer, 0, sizeof(muxer));
1142 muxer.proc = copy_to_sideband;
1143 muxer.in = -1;
1144 code = start_async(&muxer);
1145 if (code)
1146 return code;
1147 proc.err = muxer.in;
1148 } else {
1149 proc.err = 0;
1150 }
1151
1152 code = start_command(&proc);
1153 if (code) {
1154 if (use_sideband)
1155 finish_async(&muxer);
1156 return code;
1157 }
1158
1159 sigchain_push(SIGPIPE, SIG_IGN);
1160
1161 /* Version negotiaton */
1162 packet_reader_init(&reader, proc.out, NULL, 0,
1163 PACKET_READ_CHOMP_NEWLINE |
1164 PACKET_READ_GENTLE_ON_EOF);
1165 if (use_atomic)
1166 strbuf_addstr(&cap, " atomic");
1167 if (use_push_options)
1168 strbuf_addstr(&cap, " push-options");
1169 if (cap.len) {
1170 code = packet_write_fmt_gently(proc.in, "version=1%c%s\n", '\0', cap.buf + 1);
1171 strbuf_release(&cap);
1172 } else {
1173 code = packet_write_fmt_gently(proc.in, "version=1\n");
1174 }
1175 if (!code)
1176 code = packet_flush_gently(proc.in);
1177
1178 if (!code)
1179 for (;;) {
1180 int linelen;
1181 enum packet_read_status status;
1182
1183 status = packet_reader_read(&reader);
1184 if (status != PACKET_READ_NORMAL) {
1185 /* Check whether proc-receive exited abnormally */
1186 if (status == PACKET_READ_EOF)
1187 code = -1;
1188 break;
1189 }
1190
1191 if (reader.pktlen > 8 && starts_with(reader.line, "version=")) {
1192 version = atoi(reader.line + 8);
1193 linelen = strlen(reader.line);
1194 if (linelen < reader.pktlen) {
1195 const char *feature_list = reader.line + linelen + 1;
1196 if (parse_feature_request(feature_list, "push-options"))
1197 hook_use_push_options = 1;
1198 }
1199 }
1200 }
1201
1202 if (code) {
1203 strbuf_addstr(&errmsg, "fail to negotiate version with proc-receive hook");
1204 goto cleanup;
1205 }
1206
1207 switch (version) {
1208 case 0:
1209 /* fallthrough */
1210 case 1:
1211 break;
1212 default:
1213 strbuf_addf(&errmsg, "proc-receive version '%d' is not supported",
1214 version);
1215 code = -1;
1216 goto cleanup;
1217 }
1218
1219 /* Send commands */
1220 for (cmd = commands; cmd; cmd = cmd->next) {
1221 if (!cmd->run_proc_receive || cmd->skip_update || cmd->error_string)
1222 continue;
1223 code = packet_write_fmt_gently(proc.in, "%s %s %s",
1224 oid_to_hex(&cmd->old_oid),
1225 oid_to_hex(&cmd->new_oid),
1226 cmd->ref_name);
1227 if (code)
1228 break;
1229 }
1230 if (!code)
1231 code = packet_flush_gently(proc.in);
1232 if (code) {
1233 strbuf_addstr(&errmsg, "fail to write commands to proc-receive hook");
1234 goto cleanup;
1235 }
1236
1237 /* Send push options */
1238 if (hook_use_push_options) {
1239 struct string_list_item *item;
1240
1241 for_each_string_list_item(item, push_options) {
1242 code = packet_write_fmt_gently(proc.in, "%s", item->string);
1243 if (code)
1244 break;
1245 }
1246 if (!code)
1247 code = packet_flush_gently(proc.in);
1248 if (code) {
1249 strbuf_addstr(&errmsg,
1250 "fail to write push-options to proc-receive hook");
1251 goto cleanup;
1252 }
1253 }
1254
1255 /* Read result from proc-receive */
1256 code = read_proc_receive_report(&reader, commands, &errmsg);
1257
1258 cleanup:
1259 close(proc.in);
1260 close(proc.out);
1261 if (use_sideband)
1262 finish_async(&muxer);
1263 if (finish_command(&proc))
1264 code = -1;
1265 if (errmsg.len >0) {
1266 char *p = errmsg.buf;
1267
1268 p += errmsg.len - 1;
1269 if (*p == '\n')
1270 *p = '\0';
1271 rp_error("%s", errmsg.buf);
1272 strbuf_release(&errmsg);
1273 }
1274 sigchain_pop(SIGPIPE);
1275
1276 return code;
1277 }
1278
1279 static char *refuse_unconfigured_deny_msg =
1280 N_("By default, updating the current branch in a non-bare repository\n"
1281 "is denied, because it will make the index and work tree inconsistent\n"
1282 "with what you pushed, and will require 'git reset --hard' to match\n"
1283 "the work tree to HEAD.\n"
1284 "\n"
1285 "You can set the 'receive.denyCurrentBranch' configuration variable\n"
1286 "to 'ignore' or 'warn' in the remote repository to allow pushing into\n"
1287 "its current branch; however, this is not recommended unless you\n"
1288 "arranged to update its work tree to match what you pushed in some\n"
1289 "other way.\n"
1290 "\n"
1291 "To squelch this message and still keep the default behaviour, set\n"
1292 "'receive.denyCurrentBranch' configuration variable to 'refuse'.");
1293
1294 static void refuse_unconfigured_deny(void)
1295 {
1296 rp_error("%s", _(refuse_unconfigured_deny_msg));
1297 }
1298
1299 static char *refuse_unconfigured_deny_delete_current_msg =
1300 N_("By default, deleting the current branch is denied, because the next\n"
1301 "'git clone' won't result in any file checked out, causing confusion.\n"
1302 "\n"
1303 "You can set 'receive.denyDeleteCurrent' configuration variable to\n"
1304 "'warn' or 'ignore' in the remote repository to allow deleting the\n"
1305 "current branch, with or without a warning message.\n"
1306 "\n"
1307 "To squelch this message, you can set it to 'refuse'.");
1308
1309 static void refuse_unconfigured_deny_delete_current(void)
1310 {
1311 rp_error("%s", _(refuse_unconfigured_deny_delete_current_msg));
1312 }
1313
1314 static const struct object_id *command_singleton_iterator(void *cb_data);
1315 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
1316 {
1317 struct shallow_lock shallow_lock = SHALLOW_LOCK_INIT;
1318 struct oid_array extra = OID_ARRAY_INIT;
1319 struct check_connected_options opt = CHECK_CONNECTED_INIT;
1320 uint32_t mask = 1 << (cmd->index % 32);
1321 int i;
1322
1323 trace_printf_key(&trace_shallow,
1324 "shallow: update_shallow_ref %s\n", cmd->ref_name);
1325 for (i = 0; i < si->shallow->nr; i++)
1326 if (si->used_shallow[i] &&
1327 (si->used_shallow[i][cmd->index / 32] & mask) &&
1328 !delayed_reachability_test(si, i))
1329 oid_array_append(&extra, &si->shallow->oid[i]);
1330
1331 opt.env = tmp_objdir_env(tmp_objdir);
1332 setup_alternate_shallow(&shallow_lock, &opt.shallow_file, &extra);
1333 if (check_connected(command_singleton_iterator, cmd, &opt)) {
1334 rollback_shallow_file(the_repository, &shallow_lock);
1335 oid_array_clear(&extra);
1336 return -1;
1337 }
1338
1339 commit_shallow_file(the_repository, &shallow_lock);
1340
1341 /*
1342 * Make sure setup_alternate_shallow() for the next ref does
1343 * not lose these new roots..
1344 */
1345 for (i = 0; i < extra.nr; i++)
1346 register_shallow(the_repository, &extra.oid[i]);
1347
1348 si->shallow_ref[cmd->index] = 0;
1349 oid_array_clear(&extra);
1350 return 0;
1351 }
1352
1353 /*
1354 * NEEDSWORK: we should consolidate various implementions of "are we
1355 * on an unborn branch?" test into one, and make the unified one more
1356 * robust. !get_sha1() based check used here and elsewhere would not
1357 * allow us to tell an unborn branch from corrupt ref, for example.
1358 * For the purpose of fixing "deploy-to-update does not work when
1359 * pushing into an empty repository" issue, this should suffice for
1360 * now.
1361 */
1362 static int head_has_history(void)
1363 {
1364 struct object_id oid;
1365
1366 return !get_oid("HEAD", &oid);
1367 }
1368
1369 static const char *push_to_deploy(unsigned char *sha1,
1370 struct strvec *env,
1371 const char *work_tree)
1372 {
1373 const char *update_refresh[] = {
1374 "update-index", "-q", "--ignore-submodules", "--refresh", NULL
1375 };
1376 const char *diff_files[] = {
1377 "diff-files", "--quiet", "--ignore-submodules", "--", NULL
1378 };
1379 const char *diff_index[] = {
1380 "diff-index", "--quiet", "--cached", "--ignore-submodules",
1381 NULL, "--", NULL
1382 };
1383 const char *read_tree[] = {
1384 "read-tree", "-u", "-m", NULL, NULL
1385 };
1386 struct child_process child = CHILD_PROCESS_INIT;
1387
1388 child.argv = update_refresh;
1389 child.env = env->v;
1390 child.dir = work_tree;
1391 child.no_stdin = 1;
1392 child.stdout_to_stderr = 1;
1393 child.git_cmd = 1;
1394 if (run_command(&child))
1395 return "Up-to-date check failed";
1396
1397 /* run_command() does not clean up completely; reinitialize */
1398 child_process_init(&child);
1399 child.argv = diff_files;
1400 child.env = env->v;
1401 child.dir = work_tree;
1402 child.no_stdin = 1;
1403 child.stdout_to_stderr = 1;
1404 child.git_cmd = 1;
1405 if (run_command(&child))
1406 return "Working directory has unstaged changes";
1407
1408 /* diff-index with either HEAD or an empty tree */
1409 diff_index[4] = head_has_history() ? "HEAD" : empty_tree_oid_hex();
1410
1411 child_process_init(&child);
1412 child.argv = diff_index;
1413 child.env = env->v;
1414 child.no_stdin = 1;
1415 child.no_stdout = 1;
1416 child.stdout_to_stderr = 0;
1417 child.git_cmd = 1;
1418 if (run_command(&child))
1419 return "Working directory has staged changes";
1420
1421 read_tree[3] = hash_to_hex(sha1);
1422 child_process_init(&child);
1423 child.argv = read_tree;
1424 child.env = env->v;
1425 child.dir = work_tree;
1426 child.no_stdin = 1;
1427 child.no_stdout = 1;
1428 child.stdout_to_stderr = 0;
1429 child.git_cmd = 1;
1430 if (run_command(&child))
1431 return "Could not update working tree to new HEAD";
1432
1433 return NULL;
1434 }
1435
1436 static const char *push_to_checkout_hook = "push-to-checkout";
1437
1438 static const char *push_to_checkout(unsigned char *hash,
1439 struct strvec *env,
1440 const char *work_tree)
1441 {
1442 strvec_pushf(env, "GIT_WORK_TREE=%s", absolute_path(work_tree));
1443 if (run_hook_le(env->v, push_to_checkout_hook,
1444 hash_to_hex(hash), NULL))
1445 return "push-to-checkout hook declined";
1446 else
1447 return NULL;
1448 }
1449
1450 static const char *update_worktree(unsigned char *sha1, const struct worktree *worktree)
1451 {
1452 const char *retval, *work_tree, *git_dir = NULL;
1453 struct strvec env = STRVEC_INIT;
1454
1455 if (worktree && worktree->path)
1456 work_tree = worktree->path;
1457 else if (git_work_tree_cfg)
1458 work_tree = git_work_tree_cfg;
1459 else
1460 work_tree = "..";
1461
1462 if (is_bare_repository())
1463 return "denyCurrentBranch = updateInstead needs a worktree";
1464 if (worktree)
1465 git_dir = get_worktree_git_dir(worktree);
1466 if (!git_dir)
1467 git_dir = get_git_dir();
1468
1469 strvec_pushf(&env, "GIT_DIR=%s", absolute_path(git_dir));
1470
1471 if (!hook_exists(push_to_checkout_hook))
1472 retval = push_to_deploy(sha1, &env, work_tree);
1473 else
1474 retval = push_to_checkout(sha1, &env, work_tree);
1475
1476 strvec_clear(&env);
1477 return retval;
1478 }
1479
1480 static const char *update(struct command *cmd, struct shallow_info *si)
1481 {
1482 const char *name = cmd->ref_name;
1483 struct strbuf namespaced_name_buf = STRBUF_INIT;
1484 static char *namespaced_name;
1485 const char *ret;
1486 struct object_id *old_oid = &cmd->old_oid;
1487 struct object_id *new_oid = &cmd->new_oid;
1488 int do_update_worktree = 0;
1489 const struct worktree *worktree = is_bare_repository() ? NULL : find_shared_symref("HEAD", name);
1490
1491 /* only refs/... are allowed */
1492 if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
1493 rp_error("refusing to create funny ref '%s' remotely", name);
1494 return "funny refname";
1495 }
1496
1497 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
1498 free(namespaced_name);
1499 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
1500
1501 if (worktree) {
1502 switch (deny_current_branch) {
1503 case DENY_IGNORE:
1504 break;
1505 case DENY_WARN:
1506 rp_warning("updating the current branch");
1507 break;
1508 case DENY_REFUSE:
1509 case DENY_UNCONFIGURED:
1510 rp_error("refusing to update checked out branch: %s", name);
1511 if (deny_current_branch == DENY_UNCONFIGURED)
1512 refuse_unconfigured_deny();
1513 return "branch is currently checked out";
1514 case DENY_UPDATE_INSTEAD:
1515 /* pass -- let other checks intervene first */
1516 do_update_worktree = 1;
1517 break;
1518 }
1519 }
1520
1521 if (!is_null_oid(new_oid) && !has_object_file(new_oid)) {
1522 error("unpack should have generated %s, "
1523 "but I can't find it!", oid_to_hex(new_oid));
1524 return "bad pack";
1525 }
1526
1527 if (!is_null_oid(old_oid) && is_null_oid(new_oid)) {
1528 if (deny_deletes && starts_with(name, "refs/heads/")) {
1529 rp_error("denying ref deletion for %s", name);
1530 return "deletion prohibited";
1531 }
1532
1533 if (worktree || (head_name && !strcmp(namespaced_name, head_name))) {
1534 switch (deny_delete_current) {
1535 case DENY_IGNORE:
1536 break;
1537 case DENY_WARN:
1538 rp_warning("deleting the current branch");
1539 break;
1540 case DENY_REFUSE:
1541 case DENY_UNCONFIGURED:
1542 case DENY_UPDATE_INSTEAD:
1543 if (deny_delete_current == DENY_UNCONFIGURED)
1544 refuse_unconfigured_deny_delete_current();
1545 rp_error("refusing to delete the current branch: %s", name);
1546 return "deletion of the current branch prohibited";
1547 default:
1548 return "Invalid denyDeleteCurrent setting";
1549 }
1550 }
1551 }
1552
1553 if (deny_non_fast_forwards && !is_null_oid(new_oid) &&
1554 !is_null_oid(old_oid) &&
1555 starts_with(name, "refs/heads/")) {
1556 struct object *old_object, *new_object;
1557 struct commit *old_commit, *new_commit;
1558
1559 old_object = parse_object(the_repository, old_oid);
1560 new_object = parse_object(the_repository, new_oid);
1561
1562 if (!old_object || !new_object ||
1563 old_object->type != OBJ_COMMIT ||
1564 new_object->type != OBJ_COMMIT) {
1565 error("bad sha1 objects for %s", name);
1566 return "bad ref";
1567 }
1568 old_commit = (struct commit *)old_object;
1569 new_commit = (struct commit *)new_object;
1570 if (!in_merge_bases(old_commit, new_commit)) {
1571 rp_error("denying non-fast-forward %s"
1572 " (you should pull first)", name);
1573 return "non-fast-forward";
1574 }
1575 }
1576 if (run_update_hook(cmd)) {
1577 rp_error("hook declined to update %s", name);
1578 return "hook declined";
1579 }
1580
1581 if (do_update_worktree) {
1582 ret = update_worktree(new_oid->hash, find_shared_symref("HEAD", name));
1583 if (ret)
1584 return ret;
1585 }
1586
1587 if (is_null_oid(new_oid)) {
1588 struct strbuf err = STRBUF_INIT;
1589 if (!parse_object(the_repository, old_oid)) {
1590 old_oid = NULL;
1591 if (ref_exists(name)) {
1592 rp_warning("Allowing deletion of corrupt ref.");
1593 } else {
1594 rp_warning("Deleting a non-existent ref.");
1595 cmd->did_not_exist = 1;
1596 }
1597 }
1598 if (ref_transaction_delete(transaction,
1599 namespaced_name,
1600 old_oid,
1601 0, "push", &err)) {
1602 rp_error("%s", err.buf);
1603 strbuf_release(&err);
1604 return "failed to delete";
1605 }
1606 strbuf_release(&err);
1607 return NULL; /* good */
1608 }
1609 else {
1610 struct strbuf err = STRBUF_INIT;
1611 if (shallow_update && si->shallow_ref[cmd->index] &&
1612 update_shallow_ref(cmd, si))
1613 return "shallow error";
1614
1615 if (ref_transaction_update(transaction,
1616 namespaced_name,
1617 new_oid, old_oid,
1618 0, "push",
1619 &err)) {
1620 rp_error("%s", err.buf);
1621 strbuf_release(&err);
1622
1623 return "failed to update ref";
1624 }
1625 strbuf_release(&err);
1626
1627 return NULL; /* good */
1628 }
1629 }
1630
1631 static void run_update_post_hook(struct command *commands)
1632 {
1633 struct command *cmd;
1634 struct child_process proc = CHILD_PROCESS_INIT;
1635 const char *hook;
1636
1637 hook = find_hook("post-update");
1638 if (!hook)
1639 return;
1640
1641 for (cmd = commands; cmd; cmd = cmd->next) {
1642 if (cmd->error_string || cmd->did_not_exist)
1643 continue;
1644 if (!proc.args.nr)
1645 strvec_push(&proc.args, hook);
1646 strvec_push(&proc.args, cmd->ref_name);
1647 }
1648 if (!proc.args.nr)
1649 return;
1650
1651 proc.no_stdin = 1;
1652 proc.stdout_to_stderr = 1;
1653 proc.err = use_sideband ? -1 : 0;
1654 proc.trace2_hook_name = "post-update";
1655
1656 if (!start_command(&proc)) {
1657 if (use_sideband)
1658 copy_to_sideband(proc.err, -1, NULL);
1659 finish_command(&proc);
1660 }
1661 }
1662
1663 static void check_aliased_update_internal(struct command *cmd,
1664 struct string_list *list,
1665 const char *dst_name, int flag)
1666 {
1667 struct string_list_item *item;
1668 struct command *dst_cmd;
1669
1670 if (!(flag & REF_ISSYMREF))
1671 return;
1672
1673 if (!dst_name) {
1674 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
1675 cmd->skip_update = 1;
1676 cmd->error_string = "broken symref";
1677 return;
1678 }
1679 dst_name = strip_namespace(dst_name);
1680
1681 if ((item = string_list_lookup(list, dst_name)) == NULL)
1682 return;
1683
1684 cmd->skip_update = 1;
1685
1686 dst_cmd = (struct command *) item->util;
1687
1688 if (oideq(&cmd->old_oid, &dst_cmd->old_oid) &&
1689 oideq(&cmd->new_oid, &dst_cmd->new_oid))
1690 return;
1691
1692 dst_cmd->skip_update = 1;
1693
1694 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1695 " its target '%s' (%s..%s)",
1696 cmd->ref_name,
1697 find_unique_abbrev(&cmd->old_oid, DEFAULT_ABBREV),
1698 find_unique_abbrev(&cmd->new_oid, DEFAULT_ABBREV),
1699 dst_cmd->ref_name,
1700 find_unique_abbrev(&dst_cmd->old_oid, DEFAULT_ABBREV),
1701 find_unique_abbrev(&dst_cmd->new_oid, DEFAULT_ABBREV));
1702
1703 cmd->error_string = dst_cmd->error_string =
1704 "inconsistent aliased update";
1705 }
1706
1707 static void check_aliased_update(struct command *cmd, struct string_list *list)
1708 {
1709 struct strbuf buf = STRBUF_INIT;
1710 const char *dst_name;
1711 int flag;
1712
1713 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
1714 dst_name = resolve_ref_unsafe(buf.buf, 0, NULL, &flag);
1715 check_aliased_update_internal(cmd, list, dst_name, flag);
1716 strbuf_release(&buf);
1717 }
1718
1719 static void check_aliased_updates(struct command *commands)
1720 {
1721 struct command *cmd;
1722 struct string_list ref_list = STRING_LIST_INIT_NODUP;
1723
1724 for (cmd = commands; cmd; cmd = cmd->next) {
1725 struct string_list_item *item =
1726 string_list_append(&ref_list, cmd->ref_name);
1727 item->util = (void *)cmd;
1728 }
1729 string_list_sort(&ref_list);
1730
1731 for (cmd = commands; cmd; cmd = cmd->next) {
1732 if (!cmd->error_string)
1733 check_aliased_update(cmd, &ref_list);
1734 }
1735
1736 string_list_clear(&ref_list, 0);
1737 }
1738
1739 static const struct object_id *command_singleton_iterator(void *cb_data)
1740 {
1741 struct command **cmd_list = cb_data;
1742 struct command *cmd = *cmd_list;
1743
1744 if (!cmd || is_null_oid(&cmd->new_oid))
1745 return NULL;
1746 *cmd_list = NULL; /* this returns only one */
1747 return &cmd->new_oid;
1748 }
1749
1750 static void set_connectivity_errors(struct command *commands,
1751 struct shallow_info *si)
1752 {
1753 struct command *cmd;
1754
1755 for (cmd = commands; cmd; cmd = cmd->next) {
1756 struct command *singleton = cmd;
1757 struct check_connected_options opt = CHECK_CONNECTED_INIT;
1758
1759 if (shallow_update && si->shallow_ref[cmd->index])
1760 /* to be checked in update_shallow_ref() */
1761 continue;
1762
1763 opt.env = tmp_objdir_env(tmp_objdir);
1764 if (!check_connected(command_singleton_iterator, &singleton,
1765 &opt))
1766 continue;
1767
1768 cmd->error_string = "missing necessary objects";
1769 }
1770 }
1771
1772 struct iterate_data {
1773 struct command *cmds;
1774 struct shallow_info *si;
1775 };
1776
1777 static const struct object_id *iterate_receive_command_list(void *cb_data)
1778 {
1779 struct iterate_data *data = cb_data;
1780 struct command **cmd_list = &data->cmds;
1781 struct command *cmd = *cmd_list;
1782
1783 for (; cmd; cmd = cmd->next) {
1784 if (shallow_update && data->si->shallow_ref[cmd->index])
1785 /* to be checked in update_shallow_ref() */
1786 continue;
1787 if (!is_null_oid(&cmd->new_oid) && !cmd->skip_update) {
1788 *cmd_list = cmd->next;
1789 return &cmd->new_oid;
1790 }
1791 }
1792 return NULL;
1793 }
1794
1795 static void reject_updates_to_hidden(struct command *commands)
1796 {
1797 struct strbuf refname_full = STRBUF_INIT;
1798 size_t prefix_len;
1799 struct command *cmd;
1800
1801 strbuf_addstr(&refname_full, get_git_namespace());
1802 prefix_len = refname_full.len;
1803
1804 for (cmd = commands; cmd; cmd = cmd->next) {
1805 if (cmd->error_string)
1806 continue;
1807
1808 strbuf_setlen(&refname_full, prefix_len);
1809 strbuf_addstr(&refname_full, cmd->ref_name);
1810
1811 if (!ref_is_hidden(cmd->ref_name, refname_full.buf))
1812 continue;
1813 if (is_null_oid(&cmd->new_oid))
1814 cmd->error_string = "deny deleting a hidden ref";
1815 else
1816 cmd->error_string = "deny updating a hidden ref";
1817 }
1818
1819 strbuf_release(&refname_full);
1820 }
1821
1822 static int should_process_cmd(struct command *cmd)
1823 {
1824 return !cmd->error_string && !cmd->skip_update;
1825 }
1826
1827 static void warn_if_skipped_connectivity_check(struct command *commands,
1828 struct shallow_info *si)
1829 {
1830 struct command *cmd;
1831 int checked_connectivity = 1;
1832
1833 for (cmd = commands; cmd; cmd = cmd->next) {
1834 if (should_process_cmd(cmd) && si->shallow_ref[cmd->index]) {
1835 error("BUG: connectivity check has not been run on ref %s",
1836 cmd->ref_name);
1837 checked_connectivity = 0;
1838 }
1839 }
1840 if (!checked_connectivity)
1841 BUG("connectivity check skipped???");
1842 }
1843
1844 static void execute_commands_non_atomic(struct command *commands,
1845 struct shallow_info *si)
1846 {
1847 struct command *cmd;
1848 struct strbuf err = STRBUF_INIT;
1849
1850 for (cmd = commands; cmd; cmd = cmd->next) {
1851 if (!should_process_cmd(cmd) || cmd->run_proc_receive)
1852 continue;
1853
1854 transaction = ref_transaction_begin(&err);
1855 if (!transaction) {
1856 rp_error("%s", err.buf);
1857 strbuf_reset(&err);
1858 cmd->error_string = "transaction failed to start";
1859 continue;
1860 }
1861
1862 cmd->error_string = update(cmd, si);
1863
1864 if (!cmd->error_string
1865 && ref_transaction_commit(transaction, &err)) {
1866 rp_error("%s", err.buf);
1867 strbuf_reset(&err);
1868 cmd->error_string = "failed to update ref";
1869 }
1870 ref_transaction_free(transaction);
1871 }
1872 strbuf_release(&err);
1873 }
1874
1875 static void execute_commands_atomic(struct command *commands,
1876 struct shallow_info *si)
1877 {
1878 struct command *cmd;
1879 struct strbuf err = STRBUF_INIT;
1880 const char *reported_error = "atomic push failure";
1881
1882 transaction = ref_transaction_begin(&err);
1883 if (!transaction) {
1884 rp_error("%s", err.buf);
1885 strbuf_reset(&err);
1886 reported_error = "transaction failed to start";
1887 goto failure;
1888 }
1889
1890 for (cmd = commands; cmd; cmd = cmd->next) {
1891 if (!should_process_cmd(cmd) || cmd->run_proc_receive)
1892 continue;
1893
1894 cmd->error_string = update(cmd, si);
1895
1896 if (cmd->error_string)
1897 goto failure;
1898 }
1899
1900 if (ref_transaction_commit(transaction, &err)) {
1901 rp_error("%s", err.buf);
1902 reported_error = "atomic transaction failed";
1903 goto failure;
1904 }
1905 goto cleanup;
1906
1907 failure:
1908 for (cmd = commands; cmd; cmd = cmd->next)
1909 if (!cmd->error_string)
1910 cmd->error_string = reported_error;
1911
1912 cleanup:
1913 ref_transaction_free(transaction);
1914 strbuf_release(&err);
1915 }
1916
1917 static void execute_commands(struct command *commands,
1918 const char *unpacker_error,
1919 struct shallow_info *si,
1920 const struct string_list *push_options)
1921 {
1922 struct check_connected_options opt = CHECK_CONNECTED_INIT;
1923 struct command *cmd;
1924 struct iterate_data data;
1925 struct async muxer;
1926 int err_fd = 0;
1927 int run_proc_receive = 0;
1928
1929 if (unpacker_error) {
1930 for (cmd = commands; cmd; cmd = cmd->next)
1931 cmd->error_string = "unpacker error";
1932 return;
1933 }
1934
1935 if (use_sideband) {
1936 memset(&muxer, 0, sizeof(muxer));
1937 muxer.proc = copy_to_sideband;
1938 muxer.in = -1;
1939 if (!start_async(&muxer))
1940 err_fd = muxer.in;
1941 /* ...else, continue without relaying sideband */
1942 }
1943
1944 data.cmds = commands;
1945 data.si = si;
1946 opt.err_fd = err_fd;
1947 opt.progress = err_fd && !quiet;
1948 opt.env = tmp_objdir_env(tmp_objdir);
1949 if (check_connected(iterate_receive_command_list, &data, &opt))
1950 set_connectivity_errors(commands, si);
1951
1952 if (use_sideband)
1953 finish_async(&muxer);
1954
1955 reject_updates_to_hidden(commands);
1956
1957 /*
1958 * Try to find commands that have special prefix in their reference names,
1959 * and mark them to run an external "proc-receive" hook later.
1960 */
1961 if (proc_receive_ref) {
1962 for (cmd = commands; cmd; cmd = cmd->next) {
1963 if (!should_process_cmd(cmd))
1964 continue;
1965
1966 if (proc_receive_ref_matches(cmd)) {
1967 cmd->run_proc_receive = RUN_PROC_RECEIVE_SCHEDULED;
1968 run_proc_receive = 1;
1969 }
1970 }
1971 }
1972
1973 if (run_receive_hook(commands, "pre-receive", 0, push_options)) {
1974 for (cmd = commands; cmd; cmd = cmd->next) {
1975 if (!cmd->error_string)
1976 cmd->error_string = "pre-receive hook declined";
1977 }
1978 return;
1979 }
1980
1981 /*
1982 * Now we'll start writing out refs, which means the objects need
1983 * to be in their final positions so that other processes can see them.
1984 */
1985 if (tmp_objdir_migrate(tmp_objdir) < 0) {
1986 for (cmd = commands; cmd; cmd = cmd->next) {
1987 if (!cmd->error_string)
1988 cmd->error_string = "unable to migrate objects to permanent storage";
1989 }
1990 return;
1991 }
1992 tmp_objdir = NULL;
1993
1994 check_aliased_updates(commands);
1995
1996 free(head_name_to_free);
1997 head_name = head_name_to_free = resolve_refdup("HEAD", 0, NULL, NULL);
1998
1999 if (run_proc_receive &&
2000 run_proc_receive_hook(commands, push_options))
2001 for (cmd = commands; cmd; cmd = cmd->next)
2002 if (!cmd->error_string &&
2003 !(cmd->run_proc_receive & RUN_PROC_RECEIVE_RETURNED) &&
2004 (cmd->run_proc_receive || use_atomic))
2005 cmd->error_string = "fail to run proc-receive hook";
2006
2007 if (use_atomic)
2008 execute_commands_atomic(commands, si);
2009 else
2010 execute_commands_non_atomic(commands, si);
2011
2012 if (shallow_update)
2013 warn_if_skipped_connectivity_check(commands, si);
2014 }
2015
2016 static struct command **queue_command(struct command **tail,
2017 const char *line,
2018 int linelen)
2019 {
2020 struct object_id old_oid, new_oid;
2021 struct command *cmd;
2022 const char *refname;
2023 int reflen;
2024 const char *p;
2025
2026 if (parse_oid_hex(line, &old_oid, &p) ||
2027 *p++ != ' ' ||
2028 parse_oid_hex(p, &new_oid, &p) ||
2029 *p++ != ' ')
2030 die("protocol error: expected old/new/ref, got '%s'", line);
2031
2032 refname = p;
2033 reflen = linelen - (p - line);
2034 FLEX_ALLOC_MEM(cmd, ref_name, refname, reflen);
2035 oidcpy(&cmd->old_oid, &old_oid);
2036 oidcpy(&cmd->new_oid, &new_oid);
2037 *tail = cmd;
2038 return &cmd->next;
2039 }
2040
2041 static void queue_commands_from_cert(struct command **tail,
2042 struct strbuf *push_cert)
2043 {
2044 const char *boc, *eoc;
2045
2046 if (*tail)
2047 die("protocol error: got both push certificate and unsigned commands");
2048
2049 boc = strstr(push_cert->buf, "\n\n");
2050 if (!boc)
2051 die("malformed push certificate %.*s", 100, push_cert->buf);
2052 else
2053 boc += 2;
2054 eoc = push_cert->buf + parse_signed_buffer(push_cert->buf, push_cert->len);
2055
2056 while (boc < eoc) {
2057 const char *eol = memchr(boc, '\n', eoc - boc);
2058 tail = queue_command(tail, boc, eol ? eol - boc : eoc - boc);
2059 boc = eol ? eol + 1 : eoc;
2060 }
2061 }
2062
2063 static struct command *read_head_info(struct packet_reader *reader,
2064 struct oid_array *shallow)
2065 {
2066 struct command *commands = NULL;
2067 struct command **p = &commands;
2068 for (;;) {
2069 int linelen;
2070
2071 if (packet_reader_read(reader) != PACKET_READ_NORMAL)
2072 break;
2073
2074 if (reader->pktlen > 8 && starts_with(reader->line, "shallow ")) {
2075 struct object_id oid;
2076 if (get_oid_hex(reader->line + 8, &oid))
2077 die("protocol error: expected shallow sha, got '%s'",
2078 reader->line + 8);
2079 oid_array_append(shallow, &oid);
2080 continue;
2081 }
2082
2083 linelen = strlen(reader->line);
2084 if (linelen < reader->pktlen) {
2085 const char *feature_list = reader->line + linelen + 1;
2086 const char *hash = NULL;
2087 const char *client_sid;
2088 int len = 0;
2089 if (parse_feature_request(feature_list, "report-status"))
2090 report_status = 1;
2091 if (parse_feature_request(feature_list, "report-status-v2"))
2092 report_status_v2 = 1;
2093 if (parse_feature_request(feature_list, "side-band-64k"))
2094 use_sideband = LARGE_PACKET_MAX;
2095 if (parse_feature_request(feature_list, "quiet"))
2096 quiet = 1;
2097 if (advertise_atomic_push
2098 && parse_feature_request(feature_list, "atomic"))
2099 use_atomic = 1;
2100 if (advertise_push_options
2101 && parse_feature_request(feature_list, "push-options"))
2102 use_push_options = 1;
2103 hash = parse_feature_value(feature_list, "object-format", &len, NULL);
2104 if (!hash) {
2105 hash = hash_algos[GIT_HASH_SHA1].name;
2106 len = strlen(hash);
2107 }
2108 if (xstrncmpz(the_hash_algo->name, hash, len))
2109 die("error: unsupported object format '%s'", hash);
2110 client_sid = parse_feature_value(feature_list, "session-id", &len, NULL);
2111 if (client_sid) {
2112 char *sid = xstrndup(client_sid, len);
2113 trace2_data_string("transfer", NULL, "client-sid", client_sid);
2114 free(sid);
2115 }
2116 }
2117
2118 if (!strcmp(reader->line, "push-cert")) {
2119 int true_flush = 0;
2120 int saved_options = reader->options;
2121 reader->options &= ~PACKET_READ_CHOMP_NEWLINE;
2122
2123 for (;;) {
2124 packet_reader_read(reader);
2125 if (reader->status == PACKET_READ_FLUSH) {
2126 true_flush = 1;
2127 break;
2128 }
2129 if (reader->status != PACKET_READ_NORMAL) {
2130 die("protocol error: got an unexpected packet");
2131 }
2132 if (!strcmp(reader->line, "push-cert-end\n"))
2133 break; /* end of cert */
2134 strbuf_addstr(&push_cert, reader->line);
2135 }
2136 reader->options = saved_options;
2137
2138 if (true_flush)
2139 break;
2140 continue;
2141 }
2142
2143 p = queue_command(p, reader->line, linelen);
2144 }
2145
2146 if (push_cert.len)
2147 queue_commands_from_cert(p, &push_cert);
2148
2149 return commands;
2150 }
2151
2152 static void read_push_options(struct packet_reader *reader,
2153 struct string_list *options)
2154 {
2155 while (1) {
2156 if (packet_reader_read(reader) != PACKET_READ_NORMAL)
2157 break;
2158
2159 string_list_append(options, reader->line);
2160 }
2161 }
2162
2163 static const char *parse_pack_header(struct pack_header *hdr)
2164 {
2165 switch (read_pack_header(0, hdr)) {
2166 case PH_ERROR_EOF:
2167 return "eof before pack header was fully read";
2168
2169 case PH_ERROR_PACK_SIGNATURE:
2170 return "protocol error (pack signature mismatch detected)";
2171
2172 case PH_ERROR_PROTOCOL:
2173 return "protocol error (pack version unsupported)";
2174
2175 default:
2176 return "unknown error in parse_pack_header";
2177
2178 case 0:
2179 return NULL;
2180 }
2181 }
2182
2183 static const char *pack_lockfile;
2184
2185 static void push_header_arg(struct strvec *args, struct pack_header *hdr)
2186 {
2187 strvec_pushf(args, "--pack_header=%"PRIu32",%"PRIu32,
2188 ntohl(hdr->hdr_version), ntohl(hdr->hdr_entries));
2189 }
2190
2191 static const char *unpack(int err_fd, struct shallow_info *si)
2192 {
2193 struct pack_header hdr;
2194 const char *hdr_err;
2195 int status;
2196 struct child_process child = CHILD_PROCESS_INIT;
2197 int fsck_objects = (receive_fsck_objects >= 0
2198 ? receive_fsck_objects
2199 : transfer_fsck_objects >= 0
2200 ? transfer_fsck_objects
2201 : 0);
2202
2203 hdr_err = parse_pack_header(&hdr);
2204 if (hdr_err) {
2205 if (err_fd > 0)
2206 close(err_fd);
2207 return hdr_err;
2208 }
2209
2210 if (si->nr_ours || si->nr_theirs) {
2211 alt_shallow_file = setup_temporary_shallow(si->shallow);
2212 strvec_push(&child.args, "--shallow-file");
2213 strvec_push(&child.args, alt_shallow_file);
2214 }
2215
2216 tmp_objdir = tmp_objdir_create();
2217 if (!tmp_objdir) {
2218 if (err_fd > 0)
2219 close(err_fd);
2220 return "unable to create temporary object directory";
2221 }
2222 child.env = tmp_objdir_env(tmp_objdir);
2223
2224 /*
2225 * Normally we just pass the tmp_objdir environment to the child
2226 * processes that do the heavy lifting, but we may need to see these
2227 * objects ourselves to set up shallow information.
2228 */
2229 tmp_objdir_add_as_alternate(tmp_objdir);
2230
2231 if (ntohl(hdr.hdr_entries) < unpack_limit) {
2232 strvec_push(&child.args, "unpack-objects");
2233 push_header_arg(&child.args, &hdr);
2234 if (quiet)
2235 strvec_push(&child.args, "-q");
2236 if (fsck_objects)
2237 strvec_pushf(&child.args, "--strict%s",
2238 fsck_msg_types.buf);
2239 if (max_input_size)
2240 strvec_pushf(&child.args, "--max-input-size=%"PRIuMAX,
2241 (uintmax_t)max_input_size);
2242 child.no_stdout = 1;
2243 child.err = err_fd;
2244 child.git_cmd = 1;
2245 status = run_command(&child);
2246 if (status)
2247 return "unpack-objects abnormal exit";
2248 } else {
2249 char hostname[HOST_NAME_MAX + 1];
2250
2251 strvec_pushl(&child.args, "index-pack", "--stdin", NULL);
2252 push_header_arg(&child.args, &hdr);
2253
2254 if (xgethostname(hostname, sizeof(hostname)))
2255 xsnprintf(hostname, sizeof(hostname), "localhost");
2256 strvec_pushf(&child.args,
2257 "--keep=receive-pack %"PRIuMAX" on %s",
2258 (uintmax_t)getpid(),
2259 hostname);
2260
2261 if (!quiet && err_fd)
2262 strvec_push(&child.args, "--show-resolving-progress");
2263 if (use_sideband)
2264 strvec_push(&child.args, "--report-end-of-input");
2265 if (fsck_objects)
2266 strvec_pushf(&child.args, "--strict%s",
2267 fsck_msg_types.buf);
2268 if (!reject_thin)
2269 strvec_push(&child.args, "--fix-thin");
2270 if (max_input_size)
2271 strvec_pushf(&child.args, "--max-input-size=%"PRIuMAX,
2272 (uintmax_t)max_input_size);
2273 child.out = -1;
2274 child.err = err_fd;
2275 child.git_cmd = 1;
2276 status = start_command(&child);
2277 if (status)
2278 return "index-pack fork failed";
2279 pack_lockfile = index_pack_lockfile(child.out, NULL);
2280 close(child.out);
2281 status = finish_command(&child);
2282 if (status)
2283 return "index-pack abnormal exit";
2284 reprepare_packed_git(the_repository);
2285 }
2286 return NULL;
2287 }
2288
2289 static const char *unpack_with_sideband(struct shallow_info *si)
2290 {
2291 struct async muxer;
2292 const char *ret;
2293
2294 if (!use_sideband)
2295 return unpack(0, si);
2296
2297 use_keepalive = KEEPALIVE_AFTER_NUL;
2298 memset(&muxer, 0, sizeof(muxer));
2299 muxer.proc = copy_to_sideband;
2300 muxer.in = -1;
2301 if (start_async(&muxer))
2302 return NULL;
2303
2304 ret = unpack(muxer.in, si);
2305
2306 finish_async(&muxer);
2307 return ret;
2308 }
2309
2310 static void prepare_shallow_update(struct shallow_info *si)
2311 {
2312 int i, j, k, bitmap_size = DIV_ROUND_UP(si->ref->nr, 32);
2313
2314 ALLOC_ARRAY(si->used_shallow, si->shallow->nr);
2315 assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
2316
2317 CALLOC_ARRAY(si->need_reachability_test, si->shallow->nr);
2318 CALLOC_ARRAY(si->reachable, si->shallow->nr);
2319 CALLOC_ARRAY(si->shallow_ref, si->ref->nr);
2320
2321 for (i = 0; i < si->nr_ours; i++)
2322 si->need_reachability_test[si->ours[i]] = 1;
2323
2324 for (i = 0; i < si->shallow->nr; i++) {
2325 if (!si->used_shallow[i])
2326 continue;
2327 for (j = 0; j < bitmap_size; j++) {
2328 if (!si->used_shallow[i][j])
2329 continue;
2330 si->need_reachability_test[i]++;
2331 for (k = 0; k < 32; k++)
2332 if (si->used_shallow[i][j] & (1U << k))
2333 si->shallow_ref[j * 32 + k]++;
2334 }
2335
2336 /*
2337 * true for those associated with some refs and belong
2338 * in "ours" list aka "step 7 not done yet"
2339 */
2340 si->need_reachability_test[i] =
2341 si->need_reachability_test[i] > 1;
2342 }
2343
2344 /*
2345 * keep hooks happy by forcing a temporary shallow file via
2346 * env variable because we can't add --shallow-file to every
2347 * command. check_connected() will be done with
2348 * true .git/shallow though.
2349 */
2350 setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
2351 }
2352
2353 static void update_shallow_info(struct command *commands,
2354 struct shallow_info *si,
2355 struct oid_array *ref)
2356 {
2357 struct command *cmd;
2358 int *ref_status;
2359 remove_nonexistent_theirs_shallow(si);
2360 if (!si->nr_ours && !si->nr_theirs) {
2361 shallow_update = 0;
2362 return;
2363 }
2364
2365 for (cmd = commands; cmd; cmd = cmd->next) {
2366 if (is_null_oid(&cmd->new_oid))
2367 continue;
2368 oid_array_append(ref, &cmd->new_oid);
2369 cmd->index = ref->nr - 1;
2370 }
2371 si->ref = ref;
2372
2373 if (shallow_update) {
2374 prepare_shallow_update(si);
2375 return;
2376 }
2377
2378 ALLOC_ARRAY(ref_status, ref->nr);
2379 assign_shallow_commits_to_refs(si, NULL, ref_status);
2380 for (cmd = commands; cmd; cmd = cmd->next) {
2381 if (is_null_oid(&cmd->new_oid))
2382 continue;
2383 if (ref_status[cmd->index]) {
2384 cmd->error_string = "shallow update not allowed";
2385 cmd->skip_update = 1;
2386 }
2387 }
2388 free(ref_status);
2389 }
2390
2391 static void report(struct command *commands, const char *unpack_status)
2392 {
2393 struct command *cmd;
2394 struct strbuf buf = STRBUF_INIT;
2395
2396 packet_buf_write(&buf, "unpack %s\n",
2397 unpack_status ? unpack_status : "ok");
2398 for (cmd = commands; cmd; cmd = cmd->next) {
2399 if (!cmd->error_string)
2400 packet_buf_write(&buf, "ok %s\n",
2401 cmd->ref_name);
2402 else
2403 packet_buf_write(&buf, "ng %s %s\n",
2404 cmd->ref_name, cmd->error_string);
2405 }
2406 packet_buf_flush(&buf);
2407
2408 if (use_sideband)
2409 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
2410 else
2411 write_or_die(1, buf.buf, buf.len);
2412 strbuf_release(&buf);
2413 }
2414
2415 static void report_v2(struct command *commands, const char *unpack_status)
2416 {
2417 struct command *cmd;
2418 struct strbuf buf = STRBUF_INIT;
2419 struct ref_push_report *report;
2420
2421 packet_buf_write(&buf, "unpack %s\n",
2422 unpack_status ? unpack_status : "ok");
2423 for (cmd = commands; cmd; cmd = cmd->next) {
2424 int count = 0;
2425
2426 if (cmd->error_string) {
2427 packet_buf_write(&buf, "ng %s %s\n",
2428 cmd->ref_name,
2429 cmd->error_string);
2430 continue;
2431 }
2432 packet_buf_write(&buf, "ok %s\n",
2433 cmd->ref_name);
2434 for (report = cmd->report; report; report = report->next) {
2435 if (count++ > 0)
2436 packet_buf_write(&buf, "ok %s\n",
2437 cmd->ref_name);
2438 if (report->ref_name)
2439 packet_buf_write(&buf, "option refname %s\n",
2440 report->ref_name);
2441 if (report->old_oid)
2442 packet_buf_write(&buf, "option old-oid %s\n",
2443 oid_to_hex(report->old_oid));
2444 if (report->new_oid)
2445 packet_buf_write(&buf, "option new-oid %s\n",
2446 oid_to_hex(report->new_oid));
2447 if (report->forced_update)
2448 packet_buf_write(&buf, "option forced-update\n");
2449 }
2450 }
2451 packet_buf_flush(&buf);
2452
2453 if (use_sideband)
2454 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
2455 else
2456 write_or_die(1, buf.buf, buf.len);
2457 strbuf_release(&buf);
2458 }
2459
2460 static int delete_only(struct command *commands)
2461 {
2462 struct command *cmd;
2463 for (cmd = commands; cmd; cmd = cmd->next) {
2464 if (!is_null_oid(&cmd->new_oid))
2465 return 0;
2466 }
2467 return 1;
2468 }
2469
2470 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
2471 {
2472 int advertise_refs = 0;
2473 struct command *commands;
2474 struct oid_array shallow = OID_ARRAY_INIT;
2475 struct oid_array ref = OID_ARRAY_INIT;
2476 struct shallow_info si;
2477 struct packet_reader reader;
2478
2479 struct option options[] = {
2480 OPT__QUIET(&quiet, N_("quiet")),
2481 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc, NULL),
2482 OPT_HIDDEN_BOOL(0, "http-backend-info-refs", &advertise_refs, NULL),
2483 OPT_ALIAS(0, "advertise-refs", "http-backend-info-refs"),
2484 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin, NULL),
2485 OPT_END()
2486 };
2487
2488 packet_trace_identity("receive-pack");
2489
2490 argc = parse_options(argc, argv, prefix, options, receive_pack_usage, 0);
2491
2492 if (argc > 1)
2493 usage_msg_opt(_("Too many arguments."), receive_pack_usage, options);
2494 if (argc == 0)
2495 usage_msg_opt(_("You must specify a directory."), receive_pack_usage, options);
2496
2497 service_dir = argv[0];
2498
2499 setup_path();
2500
2501 if (!enter_repo(service_dir, 0))
2502 die("'%s' does not appear to be a git repository", service_dir);
2503
2504 git_config(receive_pack_config, NULL);
2505 if (cert_nonce_seed)
2506 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
2507
2508 if (0 <= transfer_unpack_limit)
2509 unpack_limit = transfer_unpack_limit;
2510 else if (0 <= receive_unpack_limit)
2511 unpack_limit = receive_unpack_limit;
2512
2513 switch (determine_protocol_version_server()) {
2514 case protocol_v2:
2515 /*
2516 * push support for protocol v2 has not been implemented yet,
2517 * so ignore the request to use v2 and fallback to using v0.
2518 */
2519 break;
2520 case protocol_v1:
2521 /*
2522 * v1 is just the original protocol with a version string,
2523 * so just fall through after writing the version string.
2524 */
2525 if (advertise_refs || !stateless_rpc)
2526 packet_write_fmt(1, "version 1\n");
2527
2528 /* fallthrough */
2529 case protocol_v0:
2530 break;
2531 case protocol_unknown_version:
2532 BUG("unknown protocol version");
2533 }
2534
2535 if (advertise_refs || !stateless_rpc) {
2536 write_head_info();
2537 }
2538 if (advertise_refs)
2539 return 0;
2540
2541 packet_reader_init(&reader, 0, NULL, 0,
2542 PACKET_READ_CHOMP_NEWLINE |
2543 PACKET_READ_DIE_ON_ERR_PACKET);
2544
2545 if ((commands = read_head_info(&reader, &shallow)) != NULL) {
2546 const char *unpack_status = NULL;
2547 struct string_list push_options = STRING_LIST_INIT_DUP;
2548
2549 if (use_push_options)
2550 read_push_options(&reader, &push_options);
2551 if (!check_cert_push_options(&push_options)) {
2552 struct command *cmd;
2553 for (cmd = commands; cmd; cmd = cmd->next)
2554 cmd->error_string = "inconsistent push options";
2555 }
2556
2557 prepare_shallow_info(&si, &shallow);
2558 if (!si.nr_ours && !si.nr_theirs)
2559 shallow_update = 0;
2560 if (!delete_only(commands)) {
2561 unpack_status = unpack_with_sideband(&si);
2562 update_shallow_info(commands, &si, &ref);
2563 }
2564 use_keepalive = KEEPALIVE_ALWAYS;
2565 execute_commands(commands, unpack_status, &si,
2566 &push_options);
2567 if (pack_lockfile)
2568 unlink_or_warn(pack_lockfile);
2569 if (report_status_v2)
2570 report_v2(commands, unpack_status);
2571 else if (report_status)
2572 report(commands, unpack_status);
2573 run_receive_hook(commands, "post-receive", 1,
2574 &push_options);
2575 run_update_post_hook(commands);
2576 string_list_clear(&push_options, 0);
2577 if (auto_gc) {
2578 const char *argv_gc_auto[] = {
2579 "gc", "--auto", "--quiet", NULL,
2580 };
2581 struct child_process proc = CHILD_PROCESS_INIT;
2582
2583 proc.no_stdin = 1;
2584 proc.stdout_to_stderr = 1;
2585 proc.err = use_sideband ? -1 : 0;
2586 proc.git_cmd = proc.close_object_store = 1;
2587 proc.argv = argv_gc_auto;
2588
2589 if (!start_command(&proc)) {
2590 if (use_sideband)
2591 copy_to_sideband(proc.err, -1, NULL);
2592 finish_command(&proc);
2593 }
2594 }
2595 if (auto_update_server_info)
2596 update_server_info(0);
2597 clear_shallow_info(&si);
2598 }
2599 if (use_sideband)
2600 packet_flush(1);
2601 oid_array_clear(&shallow);
2602 oid_array_clear(&ref);
2603 free((void *)push_cert_nonce);
2604 return 0;
2605 }
The Best VCS Around