?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync with 2.36.5
[git.git] / builtin / receive-pack.c
blob31b48e728bedef2fae4c9024726a1222dcc81d7d
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 static char *find_header(const char *msg, size_t len, const char *key,
585 const char **next_line)
586 {
587 size_t out_len;
588 const char *val = find_header_mem(msg, len, key, &out_len);
589
590 if (!val)
591 return NULL;
592
593 if (next_line)
594 *next_line = val + out_len + 1;
595
596 return xmemdupz(val, out_len);
597 }
598
599 /*
600 * Return zero if a and b are equal up to n bytes and nonzero if they are not.
601 * This operation is guaranteed to run in constant time to avoid leaking data.
602 */
603 static int constant_memequal(const char *a, const char *b, size_t n)
604 {
605 int res = 0;
606 size_t i;
607
608 for (i = 0; i < n; i++)
609 res |= a[i] ^ b[i];
610 return res;
611 }
612
613 static const char *check_nonce(const char *buf, size_t len)
614 {
615 char *nonce = find_header(buf, len, "nonce", NULL);
616 timestamp_t stamp, ostamp;
617 char *bohmac, *expect = NULL;
618 const char *retval = NONCE_BAD;
619 size_t noncelen;
620
621 if (!nonce) {
622 retval = NONCE_MISSING;
623 goto leave;
624 } else if (!push_cert_nonce) {
625 retval = NONCE_UNSOLICITED;
626 goto leave;
627 } else if (!strcmp(push_cert_nonce, nonce)) {
628 retval = NONCE_OK;
629 goto leave;
630 }
631
632 if (!stateless_rpc) {
633 /* returned nonce MUST match what we gave out earlier */
634 retval = NONCE_BAD;
635 goto leave;
636 }
637
638 /*
639 * In stateless mode, we may be receiving a nonce issued by
640 * another instance of the server that serving the same
641 * repository, and the timestamps may not match, but the
642 * nonce-seed and dir should match, so we can recompute and
643 * report the time slop.
644 *
645 * In addition, when a nonce issued by another instance has
646 * timestamp within receive.certnonceslop seconds, we pretend
647 * as if we issued that nonce when reporting to the hook.
648 */
649
650 /* nonce is concat(<seconds-since-epoch>, "-", <hmac>) */
651 if (*nonce <= '0' || '9' < *nonce) {
652 retval = NONCE_BAD;
653 goto leave;
654 }
655 stamp = parse_timestamp(nonce, &bohmac, 10);
656 if (bohmac == nonce || bohmac[0] != '-') {
657 retval = NONCE_BAD;
658 goto leave;
659 }
660
661 noncelen = strlen(nonce);
662 expect = prepare_push_cert_nonce(service_dir, stamp);
663 if (noncelen != strlen(expect)) {
664 /* This is not even the right size. */
665 retval = NONCE_BAD;
666 goto leave;
667 }
668 if (constant_memequal(expect, nonce, noncelen)) {
669 /* Not what we would have signed earlier */
670 retval = NONCE_BAD;
671 goto leave;
672 }
673
674 /*
675 * By how many seconds is this nonce stale? Negative value
676 * would mean it was issued by another server with its clock
677 * skewed in the future.
678 */
679 ostamp = parse_timestamp(push_cert_nonce, NULL, 10);
680 nonce_stamp_slop = (long)ostamp - (long)stamp;
681
682 if (nonce_stamp_slop_limit &&
683 labs(nonce_stamp_slop) <= nonce_stamp_slop_limit) {
684 /*
685 * Pretend as if the received nonce (which passes the
686 * HMAC check, so it is not a forged by third-party)
687 * is what we issued.
688 */
689 free((void *)push_cert_nonce);
690 push_cert_nonce = xstrdup(nonce);
691 retval = NONCE_OK;
692 } else {
693 retval = NONCE_SLOP;
694 }
695
696 leave:
697 free(nonce);
698 free(expect);
699 return retval;
700 }
701
702 /*
703 * Return 1 if there is no push_cert or if the push options in push_cert are
704 * the same as those in the argument; 0 otherwise.
705 */
706 static int check_cert_push_options(const struct string_list *push_options)
707 {
708 const char *buf = push_cert.buf;
709 int len = push_cert.len;
710
711 char *option;
712 const char *next_line;
713 int options_seen = 0;
714
715 int retval = 1;
716
717 if (!len)
718 return 1;
719
720 while ((option = find_header(buf, len, "push-option", &next_line))) {
721 len -= (next_line - buf);
722 buf = next_line;
723 options_seen++;
724 if (options_seen > push_options->nr
725 || strcmp(option,
726 push_options->items[options_seen - 1].string)) {
727 retval = 0;
728 goto leave;
729 }
730 free(option);
731 }
732
733 if (options_seen != push_options->nr)
734 retval = 0;
735
736 leave:
737 free(option);
738 return retval;
739 }
740
741 static void prepare_push_cert_sha1(struct child_process *proc)
742 {
743 static int already_done;
744
745 if (!push_cert.len)
746 return;
747
748 if (!already_done) {
749 int bogs /* beginning_of_gpg_sig */;
750
751 already_done = 1;
752 if (write_object_file(push_cert.buf, push_cert.len, OBJ_BLOB,
753 &push_cert_oid))
754 oidclr(&push_cert_oid);
755
756 memset(&sigcheck, '\0', sizeof(sigcheck));
757
758 bogs = parse_signed_buffer(push_cert.buf, push_cert.len);
759 sigcheck.payload = xmemdupz(push_cert.buf, bogs);
760 sigcheck.payload_len = bogs;
761 check_signature(&sigcheck, push_cert.buf + bogs,
762 push_cert.len - bogs);
763
764 nonce_status = check_nonce(push_cert.buf, bogs);
765 }
766 if (!is_null_oid(&push_cert_oid)) {
767 strvec_pushf(&proc->env, "GIT_PUSH_CERT=%s",
768 oid_to_hex(&push_cert_oid));
769 strvec_pushf(&proc->env, "GIT_PUSH_CERT_SIGNER=%s",
770 sigcheck.signer ? sigcheck.signer : "");
771 strvec_pushf(&proc->env, "GIT_PUSH_CERT_KEY=%s",
772 sigcheck.key ? sigcheck.key : "");
773 strvec_pushf(&proc->env, "GIT_PUSH_CERT_STATUS=%c",
774 sigcheck.result);
775 if (push_cert_nonce) {
776 strvec_pushf(&proc->env,
777 "GIT_PUSH_CERT_NONCE=%s",
778 push_cert_nonce);
779 strvec_pushf(&proc->env,
780 "GIT_PUSH_CERT_NONCE_STATUS=%s",
781 nonce_status);
782 if (nonce_status == NONCE_SLOP)
783 strvec_pushf(&proc->env,
784 "GIT_PUSH_CERT_NONCE_SLOP=%ld",
785 nonce_stamp_slop);
786 }
787 }
788 }
789
790 struct receive_hook_feed_state {
791 struct command *cmd;
792 struct ref_push_report *report;
793 int skip_broken;
794 struct strbuf buf;
795 const struct string_list *push_options;
796 };
797
798 typedef int (*feed_fn)(void *, const char **, size_t *);
799 static int run_and_feed_hook(const char *hook_name, feed_fn feed,
800 struct receive_hook_feed_state *feed_state)
801 {
802 struct child_process proc = CHILD_PROCESS_INIT;
803 struct async muxer;
804 int code;
805 const char *hook_path = find_hook(hook_name);
806
807 if (!hook_path)
808 return 0;
809
810 strvec_push(&proc.args, hook_path);
811 proc.in = -1;
812 proc.stdout_to_stderr = 1;
813 proc.trace2_hook_name = hook_name;
814
815 if (feed_state->push_options) {
816 size_t i;
817 for (i = 0; i < feed_state->push_options->nr; i++)
818 strvec_pushf(&proc.env,
819 "GIT_PUSH_OPTION_%"PRIuMAX"=%s",
820 (uintmax_t)i,
821 feed_state->push_options->items[i].string);
822 strvec_pushf(&proc.env, "GIT_PUSH_OPTION_COUNT=%"PRIuMAX"",
823 (uintmax_t)feed_state->push_options->nr);
824 } else
825 strvec_pushf(&proc.env, "GIT_PUSH_OPTION_COUNT");
826
827 if (tmp_objdir)
828 strvec_pushv(&proc.env, tmp_objdir_env(tmp_objdir));
829
830 if (use_sideband) {
831 memset(&muxer, 0, sizeof(muxer));
832 muxer.proc = copy_to_sideband;
833 muxer.in = -1;
834 code = start_async(&muxer);
835 if (code)
836 return code;
837 proc.err = muxer.in;
838 }
839
840 prepare_push_cert_sha1(&proc);
841
842 code = start_command(&proc);
843 if (code) {
844 if (use_sideband)
845 finish_async(&muxer);
846 return code;
847 }
848
849 sigchain_push(SIGPIPE, SIG_IGN);
850
851 while (1) {
852 const char *buf;
853 size_t n;
854 if (feed(feed_state, &buf, &n))
855 break;
856 if (write_in_full(proc.in, buf, n) < 0)
857 break;
858 }
859 close(proc.in);
860 if (use_sideband)
861 finish_async(&muxer);
862
863 sigchain_pop(SIGPIPE);
864
865 return finish_command(&proc);
866 }
867
868 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
869 {
870 struct receive_hook_feed_state *state = state_;
871 struct command *cmd = state->cmd;
872
873 while (cmd &&
874 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
875 cmd = cmd->next;
876 if (!cmd)
877 return -1; /* EOF */
878 if (!bufp)
879 return 0; /* OK, can feed something. */
880 strbuf_reset(&state->buf);
881 if (!state->report)
882 state->report = cmd->report;
883 if (state->report) {
884 struct object_id *old_oid;
885 struct object_id *new_oid;
886 const char *ref_name;
887
888 old_oid = state->report->old_oid ? state->report->old_oid : &cmd->old_oid;
889 new_oid = state->report->new_oid ? state->report->new_oid : &cmd->new_oid;
890 ref_name = state->report->ref_name ? state->report->ref_name : cmd->ref_name;
891 strbuf_addf(&state->buf, "%s %s %s\n",
892 oid_to_hex(old_oid), oid_to_hex(new_oid),
893 ref_name);
894 state->report = state->report->next;
895 if (!state->report)
896 state->cmd = cmd->next;
897 } else {
898 strbuf_addf(&state->buf, "%s %s %s\n",
899 oid_to_hex(&cmd->old_oid), oid_to_hex(&cmd->new_oid),
900 cmd->ref_name);
901 state->cmd = cmd->next;
902 }
903 if (bufp) {
904 *bufp = state->buf.buf;
905 *sizep = state->buf.len;
906 }
907 return 0;
908 }
909
910 static int run_receive_hook(struct command *commands,
911 const char *hook_name,
912 int skip_broken,
913 const struct string_list *push_options)
914 {
915 struct receive_hook_feed_state state;
916 int status;
917
918 strbuf_init(&state.buf, 0);
919 state.cmd = commands;
920 state.skip_broken = skip_broken;
921 state.report = NULL;
922 if (feed_receive_hook(&state, NULL, NULL))
923 return 0;
924 state.cmd = commands;
925 state.push_options = push_options;
926 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
927 strbuf_release(&state.buf);
928 return status;
929 }
930
931 static int run_update_hook(struct command *cmd)
932 {
933 struct child_process proc = CHILD_PROCESS_INIT;
934 int code;
935 const char *hook_path = find_hook("update");
936
937 if (!hook_path)
938 return 0;
939
940 strvec_push(&proc.args, hook_path);
941 strvec_push(&proc.args, cmd->ref_name);
942 strvec_push(&proc.args, oid_to_hex(&cmd->old_oid));
943 strvec_push(&proc.args, oid_to_hex(&cmd->new_oid));
944
945 proc.no_stdin = 1;
946 proc.stdout_to_stderr = 1;
947 proc.err = use_sideband ? -1 : 0;
948 proc.trace2_hook_name = "update";
949
950 code = start_command(&proc);
951 if (code)
952 return code;
953 if (use_sideband)
954 copy_to_sideband(proc.err, -1, NULL);
955 return finish_command(&proc);
956 }
957
958 static struct command *find_command_by_refname(struct command *list,
959 const char *refname)
960 {
961 for (; list; list = list->next)
962 if (!strcmp(list->ref_name, refname))
963 return list;
964 return NULL;
965 }
966
967 static int read_proc_receive_report(struct packet_reader *reader,
968 struct command *commands,
969 struct strbuf *errmsg)
970 {
971 struct command *cmd;
972 struct command *hint = NULL;
973 struct ref_push_report *report = NULL;
974 int new_report = 0;
975 int code = 0;
976 int once = 0;
977 int response = 0;
978
979 for (;;) {
980 struct object_id old_oid, new_oid;
981 const char *head;
982 const char *refname;
983 char *p;
984 enum packet_read_status status;
985
986 status = packet_reader_read(reader);
987 if (status != PACKET_READ_NORMAL) {
988 /* Check whether proc-receive exited abnormally */
989 if (status == PACKET_READ_EOF && !response) {
990 strbuf_addstr(errmsg, "proc-receive exited abnormally");
991 return -1;
992 }
993 break;
994 }
995 response++;
996
997 head = reader->line;
998 p = strchr(head, ' ');
999 if (!p) {
1000 strbuf_addf(errmsg, "proc-receive reported incomplete status line: '%s'\n", head);
1001 code = -1;
1002 continue;
1003 }
1004 *p++ = '\0';
1005 if (!strcmp(head, "option")) {
1006 const char *key, *val;
1007
1008 if (!hint || !(report || new_report)) {
1009 if (!once++)
1010 strbuf_addstr(errmsg, "proc-receive reported 'option' without a matching 'ok/ng' directive\n");
1011 code = -1;
1012 continue;
1013 }
1014 if (new_report) {
1015 if (!hint->report) {
1016 CALLOC_ARRAY(hint->report, 1);
1017 report = hint->report;
1018 } else {
1019 report = hint->report;
1020 while (report->next)
1021 report = report->next;
1022 report->next = xcalloc(1, sizeof(struct ref_push_report));
1023 report = report->next;
1024 }
1025 new_report = 0;
1026 }
1027 key = p;
1028 p = strchr(key, ' ');
1029 if (p)
1030 *p++ = '\0';
1031 val = p;
1032 if (!strcmp(key, "refname"))
1033 report->ref_name = xstrdup_or_null(val);
1034 else if (!strcmp(key, "old-oid") && val &&
1035 !parse_oid_hex(val, &old_oid, &val))
1036 report->old_oid = oiddup(&old_oid);
1037 else if (!strcmp(key, "new-oid") && val &&
1038 !parse_oid_hex(val, &new_oid, &val))
1039 report->new_oid = oiddup(&new_oid);
1040 else if (!strcmp(key, "forced-update"))
1041 report->forced_update = 1;
1042 else if (!strcmp(key, "fall-through"))
1043 /* Fall through, let 'receive-pack' to execute it. */
1044 hint->run_proc_receive = 0;
1045 continue;
1046 }
1047
1048 report = NULL;
1049 new_report = 0;
1050 refname = p;
1051 p = strchr(refname, ' ');
1052 if (p)
1053 *p++ = '\0';
1054 if (strcmp(head, "ok") && strcmp(head, "ng")) {
1055 strbuf_addf(errmsg, "proc-receive reported bad status '%s' on ref '%s'\n",
1056 head, refname);
1057 code = -1;
1058 continue;
1059 }
1060
1061 /* first try searching at our hint, falling back to all refs */
1062 if (hint)
1063 hint = find_command_by_refname(hint, refname);
1064 if (!hint)
1065 hint = find_command_by_refname(commands, refname);
1066 if (!hint) {
1067 strbuf_addf(errmsg, "proc-receive reported status on unknown ref: %s\n",
1068 refname);
1069 code = -1;
1070 continue;
1071 }
1072 if (!hint->run_proc_receive) {
1073 strbuf_addf(errmsg, "proc-receive reported status on unexpected ref: %s\n",
1074 refname);
1075 code = -1;
1076 continue;
1077 }
1078 hint->run_proc_receive |= RUN_PROC_RECEIVE_RETURNED;
1079 if (!strcmp(head, "ng")) {
1080 if (p)
1081 hint->error_string = xstrdup(p);
1082 else
1083 hint->error_string = "failed";
1084 code = -1;
1085 continue;
1086 }
1087 new_report = 1;
1088 }
1089
1090 for (cmd = commands; cmd; cmd = cmd->next)
1091 if (cmd->run_proc_receive && !cmd->error_string &&
1092 !(cmd->run_proc_receive & RUN_PROC_RECEIVE_RETURNED)) {
1093 cmd->error_string = "proc-receive failed to report status";
1094 code = -1;
1095 }
1096 return code;
1097 }
1098
1099 static int run_proc_receive_hook(struct command *commands,
1100 const struct string_list *push_options)
1101 {
1102 struct child_process proc = CHILD_PROCESS_INIT;
1103 struct async muxer;
1104 struct command *cmd;
1105 struct packet_reader reader;
1106 struct strbuf cap = STRBUF_INIT;
1107 struct strbuf errmsg = STRBUF_INIT;
1108 int hook_use_push_options = 0;
1109 int version = 0;
1110 int code;
1111 const char *hook_path = find_hook("proc-receive");
1112
1113 if (!hook_path) {
1114 rp_error("cannot find hook 'proc-receive'");
1115 return -1;
1116 }
1117
1118 strvec_push(&proc.args, hook_path);
1119 proc.in = -1;
1120 proc.out = -1;
1121 proc.trace2_hook_name = "proc-receive";
1122
1123 if (use_sideband) {
1124 memset(&muxer, 0, sizeof(muxer));
1125 muxer.proc = copy_to_sideband;
1126 muxer.in = -1;
1127 code = start_async(&muxer);
1128 if (code)
1129 return code;
1130 proc.err = muxer.in;
1131 } else {
1132 proc.err = 0;
1133 }
1134
1135 code = start_command(&proc);
1136 if (code) {
1137 if (use_sideband)
1138 finish_async(&muxer);
1139 return code;
1140 }
1141
1142 sigchain_push(SIGPIPE, SIG_IGN);
1143
1144 /* Version negotiaton */
1145 packet_reader_init(&reader, proc.out, NULL, 0,
1146 PACKET_READ_CHOMP_NEWLINE |
1147 PACKET_READ_GENTLE_ON_EOF);
1148 if (use_atomic)
1149 strbuf_addstr(&cap, " atomic");
1150 if (use_push_options)
1151 strbuf_addstr(&cap, " push-options");
1152 if (cap.len) {
1153 code = packet_write_fmt_gently(proc.in, "version=1%c%s\n", '\0', cap.buf + 1);
1154 strbuf_release(&cap);
1155 } else {
1156 code = packet_write_fmt_gently(proc.in, "version=1\n");
1157 }
1158 if (!code)
1159 code = packet_flush_gently(proc.in);
1160
1161 if (!code)
1162 for (;;) {
1163 int linelen;
1164 enum packet_read_status status;
1165
1166 status = packet_reader_read(&reader);
1167 if (status != PACKET_READ_NORMAL) {
1168 /* Check whether proc-receive exited abnormally */
1169 if (status == PACKET_READ_EOF)
1170 code = -1;
1171 break;
1172 }
1173
1174 if (reader.pktlen > 8 && starts_with(reader.line, "version=")) {
1175 version = atoi(reader.line + 8);
1176 linelen = strlen(reader.line);
1177 if (linelen < reader.pktlen) {
1178 const char *feature_list = reader.line + linelen + 1;
1179 if (parse_feature_request(feature_list, "push-options"))
1180 hook_use_push_options = 1;
1181 }
1182 }
1183 }
1184
1185 if (code) {
1186 strbuf_addstr(&errmsg, "fail to negotiate version with proc-receive hook");
1187 goto cleanup;
1188 }
1189
1190 switch (version) {
1191 case 0:
1192 /* fallthrough */
1193 case 1:
1194 break;
1195 default:
1196 strbuf_addf(&errmsg, "proc-receive version '%d' is not supported",
1197 version);
1198 code = -1;
1199 goto cleanup;
1200 }
1201
1202 /* Send commands */
1203 for (cmd = commands; cmd; cmd = cmd->next) {
1204 if (!cmd->run_proc_receive || cmd->skip_update || cmd->error_string)
1205 continue;
1206 code = packet_write_fmt_gently(proc.in, "%s %s %s",
1207 oid_to_hex(&cmd->old_oid),
1208 oid_to_hex(&cmd->new_oid),
1209 cmd->ref_name);
1210 if (code)
1211 break;
1212 }
1213 if (!code)
1214 code = packet_flush_gently(proc.in);
1215 if (code) {
1216 strbuf_addstr(&errmsg, "fail to write commands to proc-receive hook");
1217 goto cleanup;
1218 }
1219
1220 /* Send push options */
1221 if (hook_use_push_options) {
1222 struct string_list_item *item;
1223
1224 for_each_string_list_item(item, push_options) {
1225 code = packet_write_fmt_gently(proc.in, "%s", item->string);
1226 if (code)
1227 break;
1228 }
1229 if (!code)
1230 code = packet_flush_gently(proc.in);
1231 if (code) {
1232 strbuf_addstr(&errmsg,
1233 "fail to write push-options to proc-receive hook");
1234 goto cleanup;
1235 }
1236 }
1237
1238 /* Read result from proc-receive */
1239 code = read_proc_receive_report(&reader, commands, &errmsg);
1240
1241 cleanup:
1242 close(proc.in);
1243 close(proc.out);
1244 if (use_sideband)
1245 finish_async(&muxer);
1246 if (finish_command(&proc))
1247 code = -1;
1248 if (errmsg.len >0) {
1249 char *p = errmsg.buf;
1250
1251 p += errmsg.len - 1;
1252 if (*p == '\n')
1253 *p = '\0';
1254 rp_error("%s", errmsg.buf);
1255 strbuf_release(&errmsg);
1256 }
1257 sigchain_pop(SIGPIPE);
1258
1259 return code;
1260 }
1261
1262 static char *refuse_unconfigured_deny_msg =
1263 N_("By default, updating the current branch in a non-bare repository\n"
1264 "is denied, because it will make the index and work tree inconsistent\n"
1265 "with what you pushed, and will require 'git reset --hard' to match\n"
1266 "the work tree to HEAD.\n"
1267 "\n"
1268 "You can set the 'receive.denyCurrentBranch' configuration variable\n"
1269 "to 'ignore' or 'warn' in the remote repository to allow pushing into\n"
1270 "its current branch; however, this is not recommended unless you\n"
1271 "arranged to update its work tree to match what you pushed in some\n"
1272 "other way.\n"
1273 "\n"
1274 "To squelch this message and still keep the default behaviour, set\n"
1275 "'receive.denyCurrentBranch' configuration variable to 'refuse'.");
1276
1277 static void refuse_unconfigured_deny(void)
1278 {
1279 rp_error("%s", _(refuse_unconfigured_deny_msg));
1280 }
1281
1282 static char *refuse_unconfigured_deny_delete_current_msg =
1283 N_("By default, deleting the current branch is denied, because the next\n"
1284 "'git clone' won't result in any file checked out, causing confusion.\n"
1285 "\n"
1286 "You can set 'receive.denyDeleteCurrent' configuration variable to\n"
1287 "'warn' or 'ignore' in the remote repository to allow deleting the\n"
1288 "current branch, with or without a warning message.\n"
1289 "\n"
1290 "To squelch this message, you can set it to 'refuse'.");
1291
1292 static void refuse_unconfigured_deny_delete_current(void)
1293 {
1294 rp_error("%s", _(refuse_unconfigured_deny_delete_current_msg));
1295 }
1296
1297 static const struct object_id *command_singleton_iterator(void *cb_data);
1298 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
1299 {
1300 struct shallow_lock shallow_lock = SHALLOW_LOCK_INIT;
1301 struct oid_array extra = OID_ARRAY_INIT;
1302 struct check_connected_options opt = CHECK_CONNECTED_INIT;
1303 uint32_t mask = 1 << (cmd->index % 32);
1304 int i;
1305
1306 trace_printf_key(&trace_shallow,
1307 "shallow: update_shallow_ref %s\n", cmd->ref_name);
1308 for (i = 0; i < si->shallow->nr; i++)
1309 if (si->used_shallow[i] &&
1310 (si->used_shallow[i][cmd->index / 32] & mask) &&
1311 !delayed_reachability_test(si, i))
1312 oid_array_append(&extra, &si->shallow->oid[i]);
1313
1314 opt.env = tmp_objdir_env(tmp_objdir);
1315 setup_alternate_shallow(&shallow_lock, &opt.shallow_file, &extra);
1316 if (check_connected(command_singleton_iterator, cmd, &opt)) {
1317 rollback_shallow_file(the_repository, &shallow_lock);
1318 oid_array_clear(&extra);
1319 return -1;
1320 }
1321
1322 commit_shallow_file(the_repository, &shallow_lock);
1323
1324 /*
1325 * Make sure setup_alternate_shallow() for the next ref does
1326 * not lose these new roots..
1327 */
1328 for (i = 0; i < extra.nr; i++)
1329 register_shallow(the_repository, &extra.oid[i]);
1330
1331 si->shallow_ref[cmd->index] = 0;
1332 oid_array_clear(&extra);
1333 return 0;
1334 }
1335
1336 /*
1337 * NEEDSWORK: we should consolidate various implementions of "are we
1338 * on an unborn branch?" test into one, and make the unified one more
1339 * robust. !get_sha1() based check used here and elsewhere would not
1340 * allow us to tell an unborn branch from corrupt ref, for example.
1341 * For the purpose of fixing "deploy-to-update does not work when
1342 * pushing into an empty repository" issue, this should suffice for
1343 * now.
1344 */
1345 static int head_has_history(void)
1346 {
1347 struct object_id oid;
1348
1349 return !get_oid("HEAD", &oid);
1350 }
1351
1352 static const char *push_to_deploy(unsigned char *sha1,
1353 struct strvec *env,
1354 const char *work_tree)
1355 {
1356 struct child_process child = CHILD_PROCESS_INIT;
1357
1358 strvec_pushl(&child.args, "update-index", "-q", "--ignore-submodules",
1359 "--refresh", NULL);
1360 strvec_pushv(&child.env, env->v);
1361 child.dir = work_tree;
1362 child.no_stdin = 1;
1363 child.stdout_to_stderr = 1;
1364 child.git_cmd = 1;
1365 if (run_command(&child))
1366 return "Up-to-date check failed";
1367
1368 /* run_command() does not clean up completely; reinitialize */
1369 child_process_init(&child);
1370 strvec_pushl(&child.args, "diff-files", "--quiet",
1371 "--ignore-submodules", "--", NULL);
1372 strvec_pushv(&child.env, env->v);
1373 child.dir = work_tree;
1374 child.no_stdin = 1;
1375 child.stdout_to_stderr = 1;
1376 child.git_cmd = 1;
1377 if (run_command(&child))
1378 return "Working directory has unstaged changes";
1379
1380 child_process_init(&child);
1381 strvec_pushl(&child.args, "diff-index", "--quiet", "--cached",
1382 "--ignore-submodules",
1383 /* diff-index with either HEAD or an empty tree */
1384 head_has_history() ? "HEAD" : empty_tree_oid_hex(),
1385 "--", NULL);
1386 strvec_pushv(&child.env, env->v);
1387 child.no_stdin = 1;
1388 child.no_stdout = 1;
1389 child.stdout_to_stderr = 0;
1390 child.git_cmd = 1;
1391 if (run_command(&child))
1392 return "Working directory has staged changes";
1393
1394 child_process_init(&child);
1395 strvec_pushl(&child.args, "read-tree", "-u", "-m", hash_to_hex(sha1),
1396 NULL);
1397 strvec_pushv(&child.env, env->v);
1398 child.dir = work_tree;
1399 child.no_stdin = 1;
1400 child.no_stdout = 1;
1401 child.stdout_to_stderr = 0;
1402 child.git_cmd = 1;
1403 if (run_command(&child))
1404 return "Could not update working tree to new HEAD";
1405
1406 return NULL;
1407 }
1408
1409 static const char *push_to_checkout_hook = "push-to-checkout";
1410
1411 static const char *push_to_checkout(unsigned char *hash,
1412 int *invoked_hook,
1413 struct strvec *env,
1414 const char *work_tree)
1415 {
1416 struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
1417 opt.invoked_hook = invoked_hook;
1418
1419 strvec_pushf(env, "GIT_WORK_TREE=%s", absolute_path(work_tree));
1420 strvec_pushv(&opt.env, env->v);
1421 strvec_push(&opt.args, hash_to_hex(hash));
1422 if (run_hooks_opt(push_to_checkout_hook, &opt))
1423 return "push-to-checkout hook declined";
1424 else
1425 return NULL;
1426 }
1427
1428 static const char *update_worktree(unsigned char *sha1, const struct worktree *worktree)
1429 {
1430 const char *retval, *git_dir;
1431 struct strvec env = STRVEC_INIT;
1432 int invoked_hook;
1433
1434 if (!worktree || !worktree->path)
1435 BUG("worktree->path must be non-NULL");
1436
1437 if (worktree->is_bare)
1438 return "denyCurrentBranch = updateInstead needs a worktree";
1439 git_dir = get_worktree_git_dir(worktree);
1440
1441 strvec_pushf(&env, "GIT_DIR=%s", absolute_path(git_dir));
1442
1443 retval = push_to_checkout(sha1, &invoked_hook, &env, worktree->path);
1444 if (!invoked_hook)
1445 retval = push_to_deploy(sha1, &env, worktree->path);
1446
1447 strvec_clear(&env);
1448 return retval;
1449 }
1450
1451 static const char *update(struct command *cmd, struct shallow_info *si)
1452 {
1453 const char *name = cmd->ref_name;
1454 struct strbuf namespaced_name_buf = STRBUF_INIT;
1455 static char *namespaced_name;
1456 const char *ret;
1457 struct object_id *old_oid = &cmd->old_oid;
1458 struct object_id *new_oid = &cmd->new_oid;
1459 int do_update_worktree = 0;
1460 struct worktree **worktrees = get_worktrees();
1461 const struct worktree *worktree =
1462 find_shared_symref(worktrees, "HEAD", name);
1463
1464 /* only refs/... are allowed */
1465 if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
1466 rp_error("refusing to create funny ref '%s' remotely", name);
1467 ret = "funny refname";
1468 goto out;
1469 }
1470
1471 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
1472 free(namespaced_name);
1473 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
1474
1475 if (worktree && !worktree->is_bare) {
1476 switch (deny_current_branch) {
1477 case DENY_IGNORE:
1478 break;
1479 case DENY_WARN:
1480 rp_warning("updating the current branch");
1481 break;
1482 case DENY_REFUSE:
1483 case DENY_UNCONFIGURED:
1484 rp_error("refusing to update checked out branch: %s", name);
1485 if (deny_current_branch == DENY_UNCONFIGURED)
1486 refuse_unconfigured_deny();
1487 ret = "branch is currently checked out";
1488 goto out;
1489 case DENY_UPDATE_INSTEAD:
1490 /* pass -- let other checks intervene first */
1491 do_update_worktree = 1;
1492 break;
1493 }
1494 }
1495
1496 if (!is_null_oid(new_oid) && !has_object_file(new_oid)) {
1497 error("unpack should have generated %s, "
1498 "but I can't find it!", oid_to_hex(new_oid));
1499 ret = "bad pack";
1500 goto out;
1501 }
1502
1503 if (!is_null_oid(old_oid) && is_null_oid(new_oid)) {
1504 if (deny_deletes && starts_with(name, "refs/heads/")) {
1505 rp_error("denying ref deletion for %s", name);
1506 ret = "deletion prohibited";
1507 goto out;
1508 }
1509
1510 if (worktree || (head_name && !strcmp(namespaced_name, head_name))) {
1511 switch (deny_delete_current) {
1512 case DENY_IGNORE:
1513 break;
1514 case DENY_WARN:
1515 rp_warning("deleting the current branch");
1516 break;
1517 case DENY_REFUSE:
1518 case DENY_UNCONFIGURED:
1519 case DENY_UPDATE_INSTEAD:
1520 if (deny_delete_current == DENY_UNCONFIGURED)
1521 refuse_unconfigured_deny_delete_current();
1522 rp_error("refusing to delete the current branch: %s", name);
1523 ret = "deletion of the current branch prohibited";
1524 goto out;
1525 default:
1526 ret = "Invalid denyDeleteCurrent setting";
1527 goto out;
1528 }
1529 }
1530 }
1531
1532 if (deny_non_fast_forwards && !is_null_oid(new_oid) &&
1533 !is_null_oid(old_oid) &&
1534 starts_with(name, "refs/heads/")) {
1535 struct object *old_object, *new_object;
1536 struct commit *old_commit, *new_commit;
1537
1538 old_object = parse_object(the_repository, old_oid);
1539 new_object = parse_object(the_repository, new_oid);
1540
1541 if (!old_object || !new_object ||
1542 old_object->type != OBJ_COMMIT ||
1543 new_object->type != OBJ_COMMIT) {
1544 error("bad sha1 objects for %s", name);
1545 ret = "bad ref";
1546 goto out;
1547 }
1548 old_commit = (struct commit *)old_object;
1549 new_commit = (struct commit *)new_object;
1550 if (!in_merge_bases(old_commit, new_commit)) {
1551 rp_error("denying non-fast-forward %s"
1552 " (you should pull first)", name);
1553 ret = "non-fast-forward";
1554 goto out;
1555 }
1556 }
1557 if (run_update_hook(cmd)) {
1558 rp_error("hook declined to update %s", name);
1559 ret = "hook declined";
1560 goto out;
1561 }
1562
1563 if (do_update_worktree) {
1564 ret = update_worktree(new_oid->hash, worktree);
1565 if (ret)
1566 goto out;
1567 }
1568
1569 if (is_null_oid(new_oid)) {
1570 struct strbuf err = STRBUF_INIT;
1571 if (!parse_object(the_repository, old_oid)) {
1572 old_oid = NULL;
1573 if (ref_exists(name)) {
1574 rp_warning("allowing deletion of corrupt ref");
1575 } else {
1576 rp_warning("deleting a non-existent ref");
1577 cmd->did_not_exist = 1;
1578 }
1579 }
1580 if (ref_transaction_delete(transaction,
1581 namespaced_name,
1582 old_oid,
1583 0, "push", &err)) {
1584 rp_error("%s", err.buf);
1585 ret = "failed to delete";
1586 } else {
1587 ret = NULL; /* good */
1588 }
1589 strbuf_release(&err);
1590 }
1591 else {
1592 struct strbuf err = STRBUF_INIT;
1593 if (shallow_update && si->shallow_ref[cmd->index] &&
1594 update_shallow_ref(cmd, si)) {
1595 ret = "shallow error";
1596 goto out;
1597 }
1598
1599 if (ref_transaction_update(transaction,
1600 namespaced_name,
1601 new_oid, old_oid,
1602 0, "push",
1603 &err)) {
1604 rp_error("%s", err.buf);
1605 ret = "failed to update ref";
1606 } else {
1607 ret = NULL; /* good */
1608 }
1609 strbuf_release(&err);
1610 }
1611
1612 out:
1613 free_worktrees(worktrees);
1614 return ret;
1615 }
1616
1617 static void run_update_post_hook(struct command *commands)
1618 {
1619 struct command *cmd;
1620 struct child_process proc = CHILD_PROCESS_INIT;
1621 const char *hook;
1622
1623 hook = find_hook("post-update");
1624 if (!hook)
1625 return;
1626
1627 for (cmd = commands; cmd; cmd = cmd->next) {
1628 if (cmd->error_string || cmd->did_not_exist)
1629 continue;
1630 if (!proc.args.nr)
1631 strvec_push(&proc.args, hook);
1632 strvec_push(&proc.args, cmd->ref_name);
1633 }
1634 if (!proc.args.nr)
1635 return;
1636
1637 proc.no_stdin = 1;
1638 proc.stdout_to_stderr = 1;
1639 proc.err = use_sideband ? -1 : 0;
1640 proc.trace2_hook_name = "post-update";
1641
1642 if (!start_command(&proc)) {
1643 if (use_sideband)
1644 copy_to_sideband(proc.err, -1, NULL);
1645 finish_command(&proc);
1646 }
1647 }
1648
1649 static void check_aliased_update_internal(struct command *cmd,
1650 struct string_list *list,
1651 const char *dst_name, int flag)
1652 {
1653 struct string_list_item *item;
1654 struct command *dst_cmd;
1655
1656 if (!(flag & REF_ISSYMREF))
1657 return;
1658
1659 if (!dst_name) {
1660 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
1661 cmd->skip_update = 1;
1662 cmd->error_string = "broken symref";
1663 return;
1664 }
1665 dst_name = strip_namespace(dst_name);
1666
1667 if (!(item = string_list_lookup(list, dst_name)))
1668 return;
1669
1670 cmd->skip_update = 1;
1671
1672 dst_cmd = (struct command *) item->util;
1673
1674 if (oideq(&cmd->old_oid, &dst_cmd->old_oid) &&
1675 oideq(&cmd->new_oid, &dst_cmd->new_oid))
1676 return;
1677
1678 dst_cmd->skip_update = 1;
1679
1680 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
1681 " its target '%s' (%s..%s)",
1682 cmd->ref_name,
1683 find_unique_abbrev(&cmd->old_oid, DEFAULT_ABBREV),
1684 find_unique_abbrev(&cmd->new_oid, DEFAULT_ABBREV),
1685 dst_cmd->ref_name,
1686 find_unique_abbrev(&dst_cmd->old_oid, DEFAULT_ABBREV),
1687 find_unique_abbrev(&dst_cmd->new_oid, DEFAULT_ABBREV));
1688
1689 cmd->error_string = dst_cmd->error_string =
1690 "inconsistent aliased update";
1691 }
1692
1693 static void check_aliased_update(struct command *cmd, struct string_list *list)
1694 {
1695 struct strbuf buf = STRBUF_INIT;
1696 const char *dst_name;
1697 int flag;
1698
1699 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
1700 dst_name = resolve_ref_unsafe(buf.buf, 0, NULL, &flag);
1701 check_aliased_update_internal(cmd, list, dst_name, flag);
1702 strbuf_release(&buf);
1703 }
1704
1705 static void check_aliased_updates(struct command *commands)
1706 {
1707 struct command *cmd;
1708 struct string_list ref_list = STRING_LIST_INIT_NODUP;
1709
1710 for (cmd = commands; cmd; cmd = cmd->next) {
1711 struct string_list_item *item =
1712 string_list_append(&ref_list, cmd->ref_name);
1713 item->util = (void *)cmd;
1714 }
1715 string_list_sort(&ref_list);
1716
1717 for (cmd = commands; cmd; cmd = cmd->next) {
1718 if (!cmd->error_string)
1719 check_aliased_update(cmd, &ref_list);
1720 }
1721
1722 string_list_clear(&ref_list, 0);
1723 }
1724
1725 static const struct object_id *command_singleton_iterator(void *cb_data)
1726 {
1727 struct command **cmd_list = cb_data;
1728 struct command *cmd = *cmd_list;
1729
1730 if (!cmd || is_null_oid(&cmd->new_oid))
1731 return NULL;
1732 *cmd_list = NULL; /* this returns only one */
1733 return &cmd->new_oid;
1734 }
1735
1736 static void set_connectivity_errors(struct command *commands,
1737 struct shallow_info *si)
1738 {
1739 struct command *cmd;
1740
1741 for (cmd = commands; cmd; cmd = cmd->next) {
1742 struct command *singleton = cmd;
1743 struct check_connected_options opt = CHECK_CONNECTED_INIT;
1744
1745 if (shallow_update && si->shallow_ref[cmd->index])
1746 /* to be checked in update_shallow_ref() */
1747 continue;
1748
1749 opt.env = tmp_objdir_env(tmp_objdir);
1750 if (!check_connected(command_singleton_iterator, &singleton,
1751 &opt))
1752 continue;
1753
1754 cmd->error_string = "missing necessary objects";
1755 }
1756 }
1757
1758 struct iterate_data {
1759 struct command *cmds;
1760 struct shallow_info *si;
1761 };
1762
1763 static const struct object_id *iterate_receive_command_list(void *cb_data)
1764 {
1765 struct iterate_data *data = cb_data;
1766 struct command **cmd_list = &data->cmds;
1767 struct command *cmd = *cmd_list;
1768
1769 for (; cmd; cmd = cmd->next) {
1770 if (shallow_update && data->si->shallow_ref[cmd->index])
1771 /* to be checked in update_shallow_ref() */
1772 continue;
1773 if (!is_null_oid(&cmd->new_oid) && !cmd->skip_update) {
1774 *cmd_list = cmd->next;
1775 return &cmd->new_oid;
1776 }
1777 }
1778 return NULL;
1779 }
1780
1781 static void reject_updates_to_hidden(struct command *commands)
1782 {
1783 struct strbuf refname_full = STRBUF_INIT;
1784 size_t prefix_len;
1785 struct command *cmd;
1786
1787 strbuf_addstr(&refname_full, get_git_namespace());
1788 prefix_len = refname_full.len;
1789
1790 for (cmd = commands; cmd; cmd = cmd->next) {
1791 if (cmd->error_string)
1792 continue;
1793
1794 strbuf_setlen(&refname_full, prefix_len);
1795 strbuf_addstr(&refname_full, cmd->ref_name);
1796
1797 if (!ref_is_hidden(cmd->ref_name, refname_full.buf))
1798 continue;
1799 if (is_null_oid(&cmd->new_oid))
1800 cmd->error_string = "deny deleting a hidden ref";
1801 else
1802 cmd->error_string = "deny updating a hidden ref";
1803 }
1804
1805 strbuf_release(&refname_full);
1806 }
1807
1808 static int should_process_cmd(struct command *cmd)
1809 {
1810 return !cmd->error_string && !cmd->skip_update;
1811 }
1812
1813 static void BUG_if_skipped_connectivity_check(struct command *commands,
1814 struct shallow_info *si)
1815 {
1816 struct command *cmd;
1817
1818 for (cmd = commands; cmd; cmd = cmd->next) {
1819 if (should_process_cmd(cmd) && si->shallow_ref[cmd->index])
1820 bug("connectivity check has not been run on ref %s",
1821 cmd->ref_name);
1822 }
1823 BUG_if_bug("connectivity check skipped???");
1824 }
1825
1826 static void execute_commands_non_atomic(struct command *commands,
1827 struct shallow_info *si)
1828 {
1829 struct command *cmd;
1830 struct strbuf err = STRBUF_INIT;
1831
1832 for (cmd = commands; cmd; cmd = cmd->next) {
1833 if (!should_process_cmd(cmd) || cmd->run_proc_receive)
1834 continue;
1835
1836 transaction = ref_transaction_begin(&err);
1837 if (!transaction) {
1838 rp_error("%s", err.buf);
1839 strbuf_reset(&err);
1840 cmd->error_string = "transaction failed to start";
1841 continue;
1842 }
1843
1844 cmd->error_string = update(cmd, si);
1845
1846 if (!cmd->error_string
1847 && ref_transaction_commit(transaction, &err)) {
1848 rp_error("%s", err.buf);
1849 strbuf_reset(&err);
1850 cmd->error_string = "failed to update ref";
1851 }
1852 ref_transaction_free(transaction);
1853 }
1854 strbuf_release(&err);
1855 }
1856
1857 static void execute_commands_atomic(struct command *commands,
1858 struct shallow_info *si)
1859 {
1860 struct command *cmd;
1861 struct strbuf err = STRBUF_INIT;
1862 const char *reported_error = "atomic push failure";
1863
1864 transaction = ref_transaction_begin(&err);
1865 if (!transaction) {
1866 rp_error("%s", err.buf);
1867 strbuf_reset(&err);
1868 reported_error = "transaction failed to start";
1869 goto failure;
1870 }
1871
1872 for (cmd = commands; cmd; cmd = cmd->next) {
1873 if (!should_process_cmd(cmd) || cmd->run_proc_receive)
1874 continue;
1875
1876 cmd->error_string = update(cmd, si);
1877
1878 if (cmd->error_string)
1879 goto failure;
1880 }
1881
1882 if (ref_transaction_commit(transaction, &err)) {
1883 rp_error("%s", err.buf);
1884 reported_error = "atomic transaction failed";
1885 goto failure;
1886 }
1887 goto cleanup;
1888
1889 failure:
1890 for (cmd = commands; cmd; cmd = cmd->next)
1891 if (!cmd->error_string)
1892 cmd->error_string = reported_error;
1893
1894 cleanup:
1895 ref_transaction_free(transaction);
1896 strbuf_release(&err);
1897 }
1898
1899 static void execute_commands(struct command *commands,
1900 const char *unpacker_error,
1901 struct shallow_info *si,
1902 const struct string_list *push_options)
1903 {
1904 struct check_connected_options opt = CHECK_CONNECTED_INIT;
1905 struct command *cmd;
1906 struct iterate_data data;
1907 struct async muxer;
1908 int err_fd = 0;
1909 int run_proc_receive = 0;
1910
1911 if (unpacker_error) {
1912 for (cmd = commands; cmd; cmd = cmd->next)
1913 cmd->error_string = "unpacker error";
1914 return;
1915 }
1916
1917 if (use_sideband) {
1918 memset(&muxer, 0, sizeof(muxer));
1919 muxer.proc = copy_to_sideband;
1920 muxer.in = -1;
1921 if (!start_async(&muxer))
1922 err_fd = muxer.in;
1923 /* ...else, continue without relaying sideband */
1924 }
1925
1926 data.cmds = commands;
1927 data.si = si;
1928 opt.err_fd = err_fd;
1929 opt.progress = err_fd && !quiet;
1930 opt.env = tmp_objdir_env(tmp_objdir);
1931 if (check_connected(iterate_receive_command_list, &data, &opt))
1932 set_connectivity_errors(commands, si);
1933
1934 if (use_sideband)
1935 finish_async(&muxer);
1936
1937 reject_updates_to_hidden(commands);
1938
1939 /*
1940 * Try to find commands that have special prefix in their reference names,
1941 * and mark them to run an external "proc-receive" hook later.
1942 */
1943 if (proc_receive_ref) {
1944 for (cmd = commands; cmd; cmd = cmd->next) {
1945 if (!should_process_cmd(cmd))
1946 continue;
1947
1948 if (proc_receive_ref_matches(cmd)) {
1949 cmd->run_proc_receive = RUN_PROC_RECEIVE_SCHEDULED;
1950 run_proc_receive = 1;
1951 }
1952 }
1953 }
1954
1955 if (run_receive_hook(commands, "pre-receive", 0, push_options)) {
1956 for (cmd = commands; cmd; cmd = cmd->next) {
1957 if (!cmd->error_string)
1958 cmd->error_string = "pre-receive hook declined";
1959 }
1960 return;
1961 }
1962
1963 /*
1964 * If there is no command ready to run, should return directly to destroy
1965 * temporary data in the quarantine area.
1966 */
1967 for (cmd = commands; cmd && cmd->error_string; cmd = cmd->next)
1968 ; /* nothing */
1969 if (!cmd)
1970 return;
1971
1972 /*
1973 * Now we'll start writing out refs, which means the objects need
1974 * to be in their final positions so that other processes can see them.
1975 */
1976 if (tmp_objdir_migrate(tmp_objdir) < 0) {
1977 for (cmd = commands; cmd; cmd = cmd->next) {
1978 if (!cmd->error_string)
1979 cmd->error_string = "unable to migrate objects to permanent storage";
1980 }
1981 return;
1982 }
1983 tmp_objdir = NULL;
1984
1985 check_aliased_updates(commands);
1986
1987 free(head_name_to_free);
1988 head_name = head_name_to_free = resolve_refdup("HEAD", 0, NULL, NULL);
1989
1990 if (run_proc_receive &&
1991 run_proc_receive_hook(commands, push_options))
1992 for (cmd = commands; cmd; cmd = cmd->next)
1993 if (!cmd->error_string &&
1994 !(cmd->run_proc_receive & RUN_PROC_RECEIVE_RETURNED) &&
1995 (cmd->run_proc_receive || use_atomic))
1996 cmd->error_string = "fail to run proc-receive hook";
1997
1998 if (use_atomic)
1999 execute_commands_atomic(commands, si);
2000 else
2001 execute_commands_non_atomic(commands, si);
2002
2003 if (shallow_update)
2004 BUG_if_skipped_connectivity_check(commands, si);
2005 }
2006
2007 static struct command **queue_command(struct command **tail,
2008 const char *line,
2009 int linelen)
2010 {
2011 struct object_id old_oid, new_oid;
2012 struct command *cmd;
2013 const char *refname;
2014 int reflen;
2015 const char *p;
2016
2017 if (parse_oid_hex(line, &old_oid, &p) ||
2018 *p++ != ' ' ||
2019 parse_oid_hex(p, &new_oid, &p) ||
2020 *p++ != ' ')
2021 die("protocol error: expected old/new/ref, got '%s'", line);
2022
2023 refname = p;
2024 reflen = linelen - (p - line);
2025 FLEX_ALLOC_MEM(cmd, ref_name, refname, reflen);
2026 oidcpy(&cmd->old_oid, &old_oid);
2027 oidcpy(&cmd->new_oid, &new_oid);
2028 *tail = cmd;
2029 return &cmd->next;
2030 }
2031
2032 static void queue_commands_from_cert(struct command **tail,
2033 struct strbuf *push_cert)
2034 {
2035 const char *boc, *eoc;
2036
2037 if (*tail)
2038 die("protocol error: got both push certificate and unsigned commands");
2039
2040 boc = strstr(push_cert->buf, "\n\n");
2041 if (!boc)
2042 die("malformed push certificate %.*s", 100, push_cert->buf);
2043 else
2044 boc += 2;
2045 eoc = push_cert->buf + parse_signed_buffer(push_cert->buf, push_cert->len);
2046
2047 while (boc < eoc) {
2048 const char *eol = memchr(boc, '\n', eoc - boc);
2049 tail = queue_command(tail, boc, eol ? eol - boc : eoc - boc);
2050 boc = eol ? eol + 1 : eoc;
2051 }
2052 }
2053
2054 static struct command *read_head_info(struct packet_reader *reader,
2055 struct oid_array *shallow)
2056 {
2057 struct command *commands = NULL;
2058 struct command **p = &commands;
2059 for (;;) {
2060 int linelen;
2061
2062 if (packet_reader_read(reader) != PACKET_READ_NORMAL)
2063 break;
2064
2065 if (reader->pktlen > 8 && starts_with(reader->line, "shallow ")) {
2066 struct object_id oid;
2067 if (get_oid_hex(reader->line + 8, &oid))
2068 die("protocol error: expected shallow sha, got '%s'",
2069 reader->line + 8);
2070 oid_array_append(shallow, &oid);
2071 continue;
2072 }
2073
2074 linelen = strlen(reader->line);
2075 if (linelen < reader->pktlen) {
2076 const char *feature_list = reader->line + linelen + 1;
2077 const char *hash = NULL;
2078 const char *client_sid;
2079 int len = 0;
2080 if (parse_feature_request(feature_list, "report-status"))
2081 report_status = 1;
2082 if (parse_feature_request(feature_list, "report-status-v2"))
2083 report_status_v2 = 1;
2084 if (parse_feature_request(feature_list, "side-band-64k"))
2085 use_sideband = LARGE_PACKET_MAX;
2086 if (parse_feature_request(feature_list, "quiet"))
2087 quiet = 1;
2088 if (advertise_atomic_push
2089 && parse_feature_request(feature_list, "atomic"))
2090 use_atomic = 1;
2091 if (advertise_push_options
2092 && parse_feature_request(feature_list, "push-options"))
2093 use_push_options = 1;
2094 hash = parse_feature_value(feature_list, "object-format", &len, NULL);
2095 if (!hash) {
2096 hash = hash_algos[GIT_HASH_SHA1].name;
2097 len = strlen(hash);
2098 }
2099 if (xstrncmpz(the_hash_algo->name, hash, len))
2100 die("error: unsupported object format '%s'", hash);
2101 client_sid = parse_feature_value(feature_list, "session-id", &len, NULL);
2102 if (client_sid) {
2103 char *sid = xstrndup(client_sid, len);
2104 trace2_data_string("transfer", NULL, "client-sid", client_sid);
2105 free(sid);
2106 }
2107 }
2108
2109 if (!strcmp(reader->line, "push-cert")) {
2110 int true_flush = 0;
2111 int saved_options = reader->options;
2112 reader->options &= ~PACKET_READ_CHOMP_NEWLINE;
2113
2114 for (;;) {
2115 packet_reader_read(reader);
2116 if (reader->status == PACKET_READ_FLUSH) {
2117 true_flush = 1;
2118 break;
2119 }
2120 if (reader->status != PACKET_READ_NORMAL) {
2121 die("protocol error: got an unexpected packet");
2122 }
2123 if (!strcmp(reader->line, "push-cert-end\n"))
2124 break; /* end of cert */
2125 strbuf_addstr(&push_cert, reader->line);
2126 }
2127 reader->options = saved_options;
2128
2129 if (true_flush)
2130 break;
2131 continue;
2132 }
2133
2134 p = queue_command(p, reader->line, linelen);
2135 }
2136
2137 if (push_cert.len)
2138 queue_commands_from_cert(p, &push_cert);
2139
2140 return commands;
2141 }
2142
2143 static void read_push_options(struct packet_reader *reader,
2144 struct string_list *options)
2145 {
2146 while (1) {
2147 if (packet_reader_read(reader) != PACKET_READ_NORMAL)
2148 break;
2149
2150 string_list_append(options, reader->line);
2151 }
2152 }
2153
2154 static const char *parse_pack_header(struct pack_header *hdr)
2155 {
2156 switch (read_pack_header(0, hdr)) {
2157 case PH_ERROR_EOF:
2158 return "eof before pack header was fully read";
2159
2160 case PH_ERROR_PACK_SIGNATURE:
2161 return "protocol error (pack signature mismatch detected)";
2162
2163 case PH_ERROR_PROTOCOL:
2164 return "protocol error (pack version unsupported)";
2165
2166 default:
2167 return "unknown error in parse_pack_header";
2168
2169 case 0:
2170 return NULL;
2171 }
2172 }
2173
2174 static const char *pack_lockfile;
2175
2176 static void push_header_arg(struct strvec *args, struct pack_header *hdr)
2177 {
2178 strvec_pushf(args, "--pack_header=%"PRIu32",%"PRIu32,
2179 ntohl(hdr->hdr_version), ntohl(hdr->hdr_entries));
2180 }
2181
2182 static const char *unpack(int err_fd, struct shallow_info *si)
2183 {
2184 struct pack_header hdr;
2185 const char *hdr_err;
2186 int status;
2187 struct child_process child = CHILD_PROCESS_INIT;
2188 int fsck_objects = (receive_fsck_objects >= 0
2189 ? receive_fsck_objects
2190 : transfer_fsck_objects >= 0
2191 ? transfer_fsck_objects
2192 : 0);
2193
2194 hdr_err = parse_pack_header(&hdr);
2195 if (hdr_err) {
2196 if (err_fd > 0)
2197 close(err_fd);
2198 return hdr_err;
2199 }
2200
2201 if (si->nr_ours || si->nr_theirs) {
2202 alt_shallow_file = setup_temporary_shallow(si->shallow);
2203 strvec_push(&child.args, "--shallow-file");
2204 strvec_push(&child.args, alt_shallow_file);
2205 }
2206
2207 tmp_objdir = tmp_objdir_create("incoming");
2208 if (!tmp_objdir) {
2209 if (err_fd > 0)
2210 close(err_fd);
2211 return "unable to create temporary object directory";
2212 }
2213 strvec_pushv(&child.env, tmp_objdir_env(tmp_objdir));
2214
2215 /*
2216 * Normally we just pass the tmp_objdir environment to the child
2217 * processes that do the heavy lifting, but we may need to see these
2218 * objects ourselves to set up shallow information.
2219 */
2220 tmp_objdir_add_as_alternate(tmp_objdir);
2221
2222 if (ntohl(hdr.hdr_entries) < unpack_limit) {
2223 strvec_push(&child.args, "unpack-objects");
2224 push_header_arg(&child.args, &hdr);
2225 if (quiet)
2226 strvec_push(&child.args, "-q");
2227 if (fsck_objects)
2228 strvec_pushf(&child.args, "--strict%s",
2229 fsck_msg_types.buf);
2230 if (max_input_size)
2231 strvec_pushf(&child.args, "--max-input-size=%"PRIuMAX,
2232 (uintmax_t)max_input_size);
2233 child.no_stdout = 1;
2234 child.err = err_fd;
2235 child.git_cmd = 1;
2236 status = run_command(&child);
2237 if (status)
2238 return "unpack-objects abnormal exit";
2239 } else {
2240 char hostname[HOST_NAME_MAX + 1];
2241
2242 strvec_pushl(&child.args, "index-pack", "--stdin", NULL);
2243 push_header_arg(&child.args, &hdr);
2244
2245 if (xgethostname(hostname, sizeof(hostname)))
2246 xsnprintf(hostname, sizeof(hostname), "localhost");
2247 strvec_pushf(&child.args,
2248 "--keep=receive-pack %"PRIuMAX" on %s",
2249 (uintmax_t)getpid(),
2250 hostname);
2251
2252 if (!quiet && err_fd)
2253 strvec_push(&child.args, "--show-resolving-progress");
2254 if (use_sideband)
2255 strvec_push(&child.args, "--report-end-of-input");
2256 if (fsck_objects)
2257 strvec_pushf(&child.args, "--strict%s",
2258 fsck_msg_types.buf);
2259 if (!reject_thin)
2260 strvec_push(&child.args, "--fix-thin");
2261 if (max_input_size)
2262 strvec_pushf(&child.args, "--max-input-size=%"PRIuMAX,
2263 (uintmax_t)max_input_size);
2264 child.out = -1;
2265 child.err = err_fd;
2266 child.git_cmd = 1;
2267 status = start_command(&child);
2268 if (status)
2269 return "index-pack fork failed";
2270 pack_lockfile = index_pack_lockfile(child.out, NULL);
2271 close(child.out);
2272 status = finish_command(&child);
2273 if (status)
2274 return "index-pack abnormal exit";
2275 reprepare_packed_git(the_repository);
2276 }
2277 return NULL;
2278 }
2279
2280 static const char *unpack_with_sideband(struct shallow_info *si)
2281 {
2282 struct async muxer;
2283 const char *ret;
2284
2285 if (!use_sideband)
2286 return unpack(0, si);
2287
2288 use_keepalive = KEEPALIVE_AFTER_NUL;
2289 memset(&muxer, 0, sizeof(muxer));
2290 muxer.proc = copy_to_sideband;
2291 muxer.in = -1;
2292 if (start_async(&muxer))
2293 return NULL;
2294
2295 ret = unpack(muxer.in, si);
2296
2297 finish_async(&muxer);
2298 return ret;
2299 }
2300
2301 static void prepare_shallow_update(struct shallow_info *si)
2302 {
2303 int i, j, k, bitmap_size = DIV_ROUND_UP(si->ref->nr, 32);
2304
2305 ALLOC_ARRAY(si->used_shallow, si->shallow->nr);
2306 assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
2307
2308 CALLOC_ARRAY(si->need_reachability_test, si->shallow->nr);
2309 CALLOC_ARRAY(si->reachable, si->shallow->nr);
2310 CALLOC_ARRAY(si->shallow_ref, si->ref->nr);
2311
2312 for (i = 0; i < si->nr_ours; i++)
2313 si->need_reachability_test[si->ours[i]] = 1;
2314
2315 for (i = 0; i < si->shallow->nr; i++) {
2316 if (!si->used_shallow[i])
2317 continue;
2318 for (j = 0; j < bitmap_size; j++) {
2319 if (!si->used_shallow[i][j])
2320 continue;
2321 si->need_reachability_test[i]++;
2322 for (k = 0; k < 32; k++)
2323 if (si->used_shallow[i][j] & (1U << k))
2324 si->shallow_ref[j * 32 + k]++;
2325 }
2326
2327 /*
2328 * true for those associated with some refs and belong
2329 * in "ours" list aka "step 7 not done yet"
2330 */
2331 si->need_reachability_test[i] =
2332 si->need_reachability_test[i] > 1;
2333 }
2334
2335 /*
2336 * keep hooks happy by forcing a temporary shallow file via
2337 * env variable because we can't add --shallow-file to every
2338 * command. check_connected() will be done with
2339 * true .git/shallow though.
2340 */
2341 setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
2342 }
2343
2344 static void update_shallow_info(struct command *commands,
2345 struct shallow_info *si,
2346 struct oid_array *ref)
2347 {
2348 struct command *cmd;
2349 int *ref_status;
2350 remove_nonexistent_theirs_shallow(si);
2351 if (!si->nr_ours && !si->nr_theirs) {
2352 shallow_update = 0;
2353 return;
2354 }
2355
2356 for (cmd = commands; cmd; cmd = cmd->next) {
2357 if (is_null_oid(&cmd->new_oid))
2358 continue;
2359 oid_array_append(ref, &cmd->new_oid);
2360 cmd->index = ref->nr - 1;
2361 }
2362 si->ref = ref;
2363
2364 if (shallow_update) {
2365 prepare_shallow_update(si);
2366 return;
2367 }
2368
2369 ALLOC_ARRAY(ref_status, ref->nr);
2370 assign_shallow_commits_to_refs(si, NULL, ref_status);
2371 for (cmd = commands; cmd; cmd = cmd->next) {
2372 if (is_null_oid(&cmd->new_oid))
2373 continue;
2374 if (ref_status[cmd->index]) {
2375 cmd->error_string = "shallow update not allowed";
2376 cmd->skip_update = 1;
2377 }
2378 }
2379 free(ref_status);
2380 }
2381
2382 static void report(struct command *commands, const char *unpack_status)
2383 {
2384 struct command *cmd;
2385 struct strbuf buf = STRBUF_INIT;
2386
2387 packet_buf_write(&buf, "unpack %s\n",
2388 unpack_status ? unpack_status : "ok");
2389 for (cmd = commands; cmd; cmd = cmd->next) {
2390 if (!cmd->error_string)
2391 packet_buf_write(&buf, "ok %s\n",
2392 cmd->ref_name);
2393 else
2394 packet_buf_write(&buf, "ng %s %s\n",
2395 cmd->ref_name, cmd->error_string);
2396 }
2397 packet_buf_flush(&buf);
2398
2399 if (use_sideband)
2400 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
2401 else
2402 write_or_die(1, buf.buf, buf.len);
2403 strbuf_release(&buf);
2404 }
2405
2406 static void report_v2(struct command *commands, const char *unpack_status)
2407 {
2408 struct command *cmd;
2409 struct strbuf buf = STRBUF_INIT;
2410 struct ref_push_report *report;
2411
2412 packet_buf_write(&buf, "unpack %s\n",
2413 unpack_status ? unpack_status : "ok");
2414 for (cmd = commands; cmd; cmd = cmd->next) {
2415 int count = 0;
2416
2417 if (cmd->error_string) {
2418 packet_buf_write(&buf, "ng %s %s\n",
2419 cmd->ref_name,
2420 cmd->error_string);
2421 continue;
2422 }
2423 packet_buf_write(&buf, "ok %s\n",
2424 cmd->ref_name);
2425 for (report = cmd->report; report; report = report->next) {
2426 if (count++ > 0)
2427 packet_buf_write(&buf, "ok %s\n",
2428 cmd->ref_name);
2429 if (report->ref_name)
2430 packet_buf_write(&buf, "option refname %s\n",
2431 report->ref_name);
2432 if (report->old_oid)
2433 packet_buf_write(&buf, "option old-oid %s\n",
2434 oid_to_hex(report->old_oid));
2435 if (report->new_oid)
2436 packet_buf_write(&buf, "option new-oid %s\n",
2437 oid_to_hex(report->new_oid));
2438 if (report->forced_update)
2439 packet_buf_write(&buf, "option forced-update\n");
2440 }
2441 }
2442 packet_buf_flush(&buf);
2443
2444 if (use_sideband)
2445 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
2446 else
2447 write_or_die(1, buf.buf, buf.len);
2448 strbuf_release(&buf);
2449 }
2450
2451 static int delete_only(struct command *commands)
2452 {
2453 struct command *cmd;
2454 for (cmd = commands; cmd; cmd = cmd->next) {
2455 if (!is_null_oid(&cmd->new_oid))
2456 return 0;
2457 }
2458 return 1;
2459 }
2460
2461 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
2462 {
2463 int advertise_refs = 0;
2464 struct command *commands;
2465 struct oid_array shallow = OID_ARRAY_INIT;
2466 struct oid_array ref = OID_ARRAY_INIT;
2467 struct shallow_info si;
2468 struct packet_reader reader;
2469
2470 struct option options[] = {
2471 OPT__QUIET(&quiet, N_("quiet")),
2472 OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc, NULL),
2473 OPT_HIDDEN_BOOL(0, "http-backend-info-refs", &advertise_refs, NULL),
2474 OPT_ALIAS(0, "advertise-refs", "http-backend-info-refs"),
2475 OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin, NULL),
2476 OPT_END()
2477 };
2478
2479 packet_trace_identity("receive-pack");
2480
2481 argc = parse_options(argc, argv, prefix, options, receive_pack_usage, 0);
2482
2483 if (argc > 1)
2484 usage_msg_opt(_("too many arguments"), receive_pack_usage, options);
2485 if (argc == 0)
2486 usage_msg_opt(_("you must specify a directory"), receive_pack_usage, options);
2487
2488 service_dir = argv[0];
2489
2490 setup_path();
2491
2492 if (!enter_repo(service_dir, 0))
2493 die("'%s' does not appear to be a git repository", service_dir);
2494
2495 git_config(receive_pack_config, NULL);
2496 if (cert_nonce_seed)
2497 push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
2498
2499 if (0 <= transfer_unpack_limit)
2500 unpack_limit = transfer_unpack_limit;
2501 else if (0 <= receive_unpack_limit)
2502 unpack_limit = receive_unpack_limit;
2503
2504 switch (determine_protocol_version_server()) {
2505 case protocol_v2:
2506 /*
2507 * push support for protocol v2 has not been implemented yet,
2508 * so ignore the request to use v2 and fallback to using v0.
2509 */
2510 break;
2511 case protocol_v1:
2512 /*
2513 * v1 is just the original protocol with a version string,
2514 * so just fall through after writing the version string.
2515 */
2516 if (advertise_refs || !stateless_rpc)
2517 packet_write_fmt(1, "version 1\n");
2518
2519 /* fallthrough */
2520 case protocol_v0:
2521 break;
2522 case protocol_unknown_version:
2523 BUG("unknown protocol version");
2524 }
2525
2526 if (advertise_refs || !stateless_rpc) {
2527 write_head_info();
2528 }
2529 if (advertise_refs)
2530 return 0;
2531
2532 packet_reader_init(&reader, 0, NULL, 0,
2533 PACKET_READ_CHOMP_NEWLINE |
2534 PACKET_READ_DIE_ON_ERR_PACKET);
2535
2536 if ((commands = read_head_info(&reader, &shallow))) {
2537 const char *unpack_status = NULL;
2538 struct string_list push_options = STRING_LIST_INIT_DUP;
2539
2540 if (use_push_options)
2541 read_push_options(&reader, &push_options);
2542 if (!check_cert_push_options(&push_options)) {
2543 struct command *cmd;
2544 for (cmd = commands; cmd; cmd = cmd->next)
2545 cmd->error_string = "inconsistent push options";
2546 }
2547
2548 prepare_shallow_info(&si, &shallow);
2549 if (!si.nr_ours && !si.nr_theirs)
2550 shallow_update = 0;
2551 if (!delete_only(commands)) {
2552 unpack_status = unpack_with_sideband(&si);
2553 update_shallow_info(commands, &si, &ref);
2554 }
2555 use_keepalive = KEEPALIVE_ALWAYS;
2556 execute_commands(commands, unpack_status, &si,
2557 &push_options);
2558 if (pack_lockfile)
2559 unlink_or_warn(pack_lockfile);
2560 sigchain_push(SIGPIPE, SIG_IGN);
2561 if (report_status_v2)
2562 report_v2(commands, unpack_status);
2563 else if (report_status)
2564 report(commands, unpack_status);
2565 sigchain_pop(SIGPIPE);
2566 run_receive_hook(commands, "post-receive", 1,
2567 &push_options);
2568 run_update_post_hook(commands);
2569 string_list_clear(&push_options, 0);
2570 if (auto_gc) {
2571 struct child_process proc = CHILD_PROCESS_INIT;
2572
2573 proc.no_stdin = 1;
2574 proc.stdout_to_stderr = 1;
2575 proc.err = use_sideband ? -1 : 0;
2576 proc.git_cmd = proc.close_object_store = 1;
2577 strvec_pushl(&proc.args, "gc", "--auto", "--quiet",
2578 NULL);
2579
2580 if (!start_command(&proc)) {
2581 if (use_sideband)
2582 copy_to_sideband(proc.err, -1, NULL);
2583 finish_command(&proc);
2584 }
2585 }
2586 if (auto_update_server_info)
2587 update_server_info(0);
2588 clear_shallow_info(&si);
2589 }
2590 if (use_sideband)
2591 packet_flush(1);
2592 oid_array_clear(&shallow);
2593 oid_array_clear(&ref);
2594 free((void *)push_cert_nonce);
2595 return 0;
2596 }
The Best VCS Around