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