freshlybakedca.ke
Git fork
1#define USE_THE_REPOSITORY_VARIABLE
2
3#include "git-compat-util.h"
4#include "advice.h"
5#include "config.h"
6#include "environment.h"
7#include "hex.h"
8#include "transport.h"
9#include "hook.h"
10#include "pkt-line.h"
11#include "fetch-pack.h"
12#include "remote.h"
13#include "connect.h"
14#include "send-pack.h"
15#include "bundle.h"
16#include "gettext.h"
17#include "refs.h"
18#include "refspec.h"
19#include "branch.h"
20#include "url.h"
21#include "submodule.h"
22#include "strbuf.h"
23#include "string-list.h"
24#include "oid-array.h"
25#include "sigchain.h"
26#include "trace2.h"
27#include "transport-internal.h"
28#include "protocol.h"
29#include "object-name.h"
30#include "color.h"
31#include "bundle-uri.h"
32
33static enum git_colorbool transport_use_color = GIT_COLOR_UNKNOWN;
34static char transport_colors[][COLOR_MAXLEN] = {
35 GIT_COLOR_RESET,
36 GIT_COLOR_RED /* REJECTED */
37};
38
39enum color_transport {
40 TRANSPORT_COLOR_RESET = 0,
41 TRANSPORT_COLOR_REJECTED = 1
42};
43
44static int transport_color_config(void)
45{
46 const char *keys[] = {
47 "color.transport.reset",
48 "color.transport.rejected"
49 }, *key = "color.transport";
50 char *value;
51 static int initialized;
52
53 if (initialized)
54 return 0;
55 initialized = 1;
56
57 if (!repo_config_get_string(the_repository, key, &value))
58 transport_use_color = git_config_colorbool(key, value);
59
60 if (!want_color_stderr(transport_use_color))
61 return 0;
62
63 for (size_t i = 0; i < ARRAY_SIZE(keys); i++)
64 if (!repo_config_get_string(the_repository, keys[i], &value)) {
65 if (!value)
66 return config_error_nonbool(keys[i]);
67 if (color_parse(value, transport_colors[i]) < 0)
68 return -1;
69 }
70
71 return 0;
72}
73
74static const char *transport_get_color(enum color_transport ix)
75{
76 if (want_color_stderr(transport_use_color))
77 return transport_colors[ix];
78 return "";
79}
80
81static void set_upstreams(struct transport *transport, struct ref *refs,
82 int pretend)
83{
84 struct ref *ref;
85 for (ref = refs; ref; ref = ref->next) {
86 const char *localname;
87 const char *tmp;
88 const char *remotename;
89 int flag = 0;
90 /*
91 * Check suitability for tracking. Must be successful /
92 * already up-to-date ref create/modify (not delete).
93 */
94 if (ref->status != REF_STATUS_OK &&
95 ref->status != REF_STATUS_UPTODATE)
96 continue;
97 if (!ref->peer_ref)
98 continue;
99 if (is_null_oid(&ref->new_oid))
100 continue;
101
102 /* Follow symbolic refs (mainly for HEAD). */
103 localname = ref->peer_ref->name;
104 remotename = ref->name;
105 tmp = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),
106 localname, RESOLVE_REF_READING,
107 NULL, &flag);
108 if (tmp && flag & REF_ISSYMREF &&
109 starts_with(tmp, "refs/heads/"))
110 localname = tmp;
111
112 /* Both source and destination must be local branches. */
113 if (!localname || !starts_with(localname, "refs/heads/"))
114 continue;
115 if (!remotename || !starts_with(remotename, "refs/heads/"))
116 continue;
117
118 if (!pretend) {
119 int flag = transport->verbose < 0 ? 0 : BRANCH_CONFIG_VERBOSE;
120 install_branch_config(flag, localname + 11,
121 transport->remote->name, remotename);
122 } else if (transport->verbose >= 0)
123 printf(_("Would set upstream of '%s' to '%s' of '%s'\n"),
124 localname + 11, remotename + 11,
125 transport->remote->name);
126 }
127}
128
129struct bundle_transport_data {
130 int fd;
131 struct bundle_header header;
132 unsigned get_refs_from_bundle_called : 1;
133};
134
135static void get_refs_from_bundle_inner(struct transport *transport)
136{
137 struct bundle_transport_data *data = transport->data;
138
139 data->get_refs_from_bundle_called = 1;
140
141 if (data->fd > 0)
142 close(data->fd);
143 data->fd = read_bundle_header(transport->url, &data->header);
144 if (data->fd < 0)
145 die(_("could not read bundle '%s'"), transport->url);
146
147 transport->hash_algo = data->header.hash_algo;
148}
149
150static struct ref *get_refs_from_bundle(struct transport *transport,
151 int for_push,
152 struct transport_ls_refs_options *transport_options UNUSED)
153{
154 struct bundle_transport_data *data = transport->data;
155 struct ref *result = NULL;
156
157 if (for_push)
158 return NULL;
159
160 get_refs_from_bundle_inner(transport);
161
162 for (size_t i = 0; i < data->header.references.nr; i++) {
163 struct string_list_item *e = data->header.references.items + i;
164 const char *name = e->string;
165 struct ref *ref = alloc_ref(name);
166 struct object_id *oid = e->util;
167 oidcpy(&ref->old_oid, oid);
168 ref->next = result;
169 result = ref;
170 }
171 return result;
172}
173
174static int fetch_fsck_config_cb(const char *var, const char *value,
175 const struct config_context *ctx UNUSED, void *cb)
176{
177 struct strbuf *msg_types = cb;
178 int ret;
179
180 ret = fetch_pack_fsck_config(var, value, msg_types);
181 if (ret > 0)
182 return 0;
183
184 return ret;
185}
186
187static int fetch_refs_from_bundle(struct transport *transport,
188 int nr_heads UNUSED,
189 struct ref **to_fetch UNUSED)
190{
191 struct unbundle_opts opts = {
192 .flags = fetch_pack_fsck_objects() ? VERIFY_BUNDLE_FSCK : 0,
193 };
194 struct bundle_transport_data *data = transport->data;
195 struct strvec extra_index_pack_args = STRVEC_INIT;
196 struct strbuf msg_types = STRBUF_INIT;
197 int ret;
198
199 if (transport->progress)
200 strvec_push(&extra_index_pack_args, "-v");
201
202 if (!data->get_refs_from_bundle_called)
203 get_refs_from_bundle_inner(transport);
204
205 repo_config(the_repository, fetch_fsck_config_cb, &msg_types);
206 opts.fsck_msg_types = msg_types.buf;
207
208 ret = unbundle(the_repository, &data->header, data->fd,
209 &extra_index_pack_args, &opts);
210 data->fd = -1; /* `unbundle()` closes the file descriptor */
211 transport->hash_algo = data->header.hash_algo;
212
213 strvec_clear(&extra_index_pack_args);
214 strbuf_release(&msg_types);
215 return ret;
216}
217
218static int close_bundle(struct transport *transport)
219{
220 struct bundle_transport_data *data = transport->data;
221 if (data->fd > 0)
222 close(data->fd);
223 bundle_header_release(&data->header);
224 free(data);
225 return 0;
226}
227
228struct git_transport_data {
229 struct git_transport_options options;
230 struct child_process *conn;
231 int fd[2];
232 unsigned finished_handshake : 1;
233 enum protocol_version version;
234 struct oid_array extra_have;
235 struct oid_array shallow;
236};
237
238static int set_git_option(struct git_transport_options *opts,
239 const char *name, const char *value)
240{
241 if (!strcmp(name, TRANS_OPT_UPLOADPACK)) {
242 opts->uploadpack = value;
243 return 0;
244 } else if (!strcmp(name, TRANS_OPT_RECEIVEPACK)) {
245 opts->receivepack = value;
246 return 0;
247 } else if (!strcmp(name, TRANS_OPT_THIN)) {
248 opts->thin = !!value;
249 return 0;
250 } else if (!strcmp(name, TRANS_OPT_FOLLOWTAGS)) {
251 opts->followtags = !!value;
252 return 0;
253 } else if (!strcmp(name, TRANS_OPT_KEEP)) {
254 opts->keep = !!value;
255 return 0;
256 } else if (!strcmp(name, TRANS_OPT_UPDATE_SHALLOW)) {
257 opts->update_shallow = !!value;
258 return 0;
259 } else if (!strcmp(name, TRANS_OPT_DEPTH)) {
260 if (!value)
261 opts->depth = 0;
262 else {
263 char *end;
264 opts->depth = strtol(value, &end, 0);
265 if (*end)
266 die(_("transport: invalid depth option '%s'"), value);
267 }
268 return 0;
269 } else if (!strcmp(name, TRANS_OPT_DEEPEN_SINCE)) {
270 opts->deepen_since = value;
271 return 0;
272 } else if (!strcmp(name, TRANS_OPT_DEEPEN_NOT)) {
273 opts->deepen_not = (const struct string_list *)value;
274 return 0;
275 } else if (!strcmp(name, TRANS_OPT_DEEPEN_RELATIVE)) {
276 opts->deepen_relative = !!value;
277 return 0;
278 } else if (!strcmp(name, TRANS_OPT_FROM_PROMISOR)) {
279 opts->from_promisor = !!value;
280 return 0;
281 } else if (!strcmp(name, TRANS_OPT_LIST_OBJECTS_FILTER)) {
282 list_objects_filter_die_if_populated(&opts->filter_options);
283 parse_list_objects_filter(&opts->filter_options, value);
284 return 0;
285 } else if (!strcmp(name, TRANS_OPT_REFETCH)) {
286 opts->refetch = !!value;
287 return 0;
288 } else if (!strcmp(name, TRANS_OPT_REJECT_SHALLOW)) {
289 opts->reject_shallow = !!value;
290 return 0;
291 }
292 return 1;
293}
294
295static int connect_setup(struct transport *transport, int for_push)
296{
297 struct git_transport_data *data = transport->data;
298 int flags = transport->verbose > 0 ? CONNECT_VERBOSE : 0;
299
300 if (data->conn)
301 return 0;
302
303 switch (transport->family) {
304 case TRANSPORT_FAMILY_ALL: break;
305 case TRANSPORT_FAMILY_IPV4: flags |= CONNECT_IPV4; break;
306 case TRANSPORT_FAMILY_IPV6: flags |= CONNECT_IPV6; break;
307 }
308
309 data->conn = git_connect(data->fd, transport->url,
310 for_push ?
311 "git-receive-pack" :
312 "git-upload-pack",
313 for_push ?
314 data->options.receivepack :
315 data->options.uploadpack,
316 flags);
317
318 return 0;
319}
320
321static void die_if_server_options(struct transport *transport)
322{
323 if (!transport->server_options || !transport->server_options->nr)
324 return;
325 advise(_("see protocol.version in 'git help config' for more details"));
326 die(_("server options require protocol version 2 or later"));
327}
328
329/*
330 * Obtains the protocol version from the transport and writes it to
331 * transport->data->version, first connecting if not already connected.
332 *
333 * If the protocol version is one that allows skipping the listing of remote
334 * refs, and must_list_refs is 0, the listing of remote refs is skipped and
335 * this function returns NULL. Otherwise, this function returns the list of
336 * remote refs.
337 */
338static struct ref *handshake(struct transport *transport, int for_push,
339 struct transport_ls_refs_options *options,
340 int must_list_refs)
341{
342 struct git_transport_data *data = transport->data;
343 struct ref *refs = NULL;
344 struct packet_reader reader;
345 size_t sid_len;
346 const char *server_sid;
347
348 connect_setup(transport, for_push);
349
350 packet_reader_init(&reader, data->fd[0], NULL, 0,
351 PACKET_READ_CHOMP_NEWLINE |
352 PACKET_READ_GENTLE_ON_EOF |
353 PACKET_READ_DIE_ON_ERR_PACKET);
354
355 data->version = discover_version(&reader);
356 switch (data->version) {
357 case protocol_v2:
358 if ((!transport->server_options || !transport->server_options->nr) &&
359 transport->remote->server_options.nr)
360 transport->server_options = &transport->remote->server_options;
361 if (server_feature_v2("session-id", &server_sid))
362 trace2_data_string("transfer", NULL, "server-sid", server_sid);
363 if (must_list_refs)
364 get_remote_refs(data->fd[1], &reader, &refs, for_push,
365 options,
366 transport->server_options,
367 transport->stateless_rpc);
368 break;
369 case protocol_v1:
370 case protocol_v0:
371 die_if_server_options(transport);
372 get_remote_heads(&reader, &refs,
373 for_push ? REF_NORMAL : 0,
374 &data->extra_have,
375 &data->shallow);
376 server_sid = server_feature_value("session-id", &sid_len);
377 if (server_sid) {
378 char *sid = xstrndup(server_sid, sid_len);
379 trace2_data_string("transfer", NULL, "server-sid", sid);
380 free(sid);
381 }
382 break;
383 case protocol_unknown_version:
384 BUG("unknown protocol version");
385 }
386 data->finished_handshake = 1;
387 transport->hash_algo = reader.hash_algo;
388
389 if (reader.line_peeked)
390 BUG("buffer must be empty at the end of handshake()");
391
392 return refs;
393}
394
395static struct ref *get_refs_via_connect(struct transport *transport, int for_push,
396 struct transport_ls_refs_options *options)
397{
398 return handshake(transport, for_push, options, 1);
399}
400
401static int get_bundle_uri(struct transport *transport)
402{
403 struct git_transport_data *data = transport->data;
404 struct packet_reader reader;
405 int stateless_rpc = transport->stateless_rpc;
406
407 if (!transport->bundles) {
408 CALLOC_ARRAY(transport->bundles, 1);
409 init_bundle_list(transport->bundles);
410 }
411
412 if (!data->finished_handshake) {
413 struct ref *refs = handshake(transport, 0, NULL, 0);
414
415 if (refs)
416 free_refs(refs);
417 }
418
419 /*
420 * "Support" protocol v0 and v2 without bundle-uri support by
421 * silently degrading to a NOOP.
422 */
423 if (!server_supports_v2("bundle-uri"))
424 return 0;
425
426 packet_reader_init(&reader, data->fd[0], NULL, 0,
427 PACKET_READ_CHOMP_NEWLINE |
428 PACKET_READ_GENTLE_ON_EOF);
429
430 return get_remote_bundle_uri(data->fd[1], &reader,
431 transport->bundles, stateless_rpc);
432}
433
434static int fetch_refs_via_pack(struct transport *transport,
435 int nr_heads, struct ref **to_fetch)
436{
437 int ret = 0;
438 struct git_transport_data *data = transport->data;
439 struct ref *refs = NULL;
440 struct fetch_pack_args args;
441 struct ref *refs_tmp = NULL, **to_fetch_dup = NULL;
442
443 memset(&args, 0, sizeof(args));
444 args.uploadpack = data->options.uploadpack;
445 args.keep_pack = data->options.keep;
446 args.lock_pack = 1;
447 args.use_thin_pack = data->options.thin;
448 args.include_tag = data->options.followtags;
449 args.verbose = (transport->verbose > 1);
450 args.quiet = (transport->verbose < 0);
451 args.no_progress = !transport->progress;
452 args.depth = data->options.depth;
453 args.deepen_since = data->options.deepen_since;
454 args.deepen_not = data->options.deepen_not;
455 args.deepen_relative = data->options.deepen_relative;
456 args.check_self_contained_and_connected =
457 data->options.check_self_contained_and_connected;
458 args.cloning = transport->cloning;
459 args.update_shallow = data->options.update_shallow;
460 args.from_promisor = data->options.from_promisor;
461 list_objects_filter_copy(&args.filter_options,
462 &data->options.filter_options);
463 args.refetch = data->options.refetch;
464 args.stateless_rpc = transport->stateless_rpc;
465 args.server_options = transport->server_options;
466 args.negotiation_tips = data->options.negotiation_tips;
467 args.reject_shallow_remote = transport->smart_options->reject_shallow;
468
469 if (!data->finished_handshake) {
470 int i;
471 int must_list_refs = 0;
472 for (i = 0; i < nr_heads; i++) {
473 if (!to_fetch[i]->exact_oid) {
474 must_list_refs = 1;
475 break;
476 }
477 }
478 refs_tmp = handshake(transport, 0, NULL, must_list_refs);
479 }
480
481 if (data->version == protocol_unknown_version)
482 BUG("unknown protocol version");
483 else if (data->version <= protocol_v1)
484 die_if_server_options(transport);
485
486 if (data->options.acked_commits) {
487 if (data->version < protocol_v2) {
488 warning(_("--negotiate-only requires protocol v2"));
489 ret = -1;
490 } else if (!server_supports_feature("fetch", "wait-for-done", 0)) {
491 warning(_("server does not support wait-for-done"));
492 ret = -1;
493 } else {
494 negotiate_using_fetch(data->options.negotiation_tips,
495 transport->server_options,
496 transport->stateless_rpc,
497 data->fd,
498 data->options.acked_commits);
499 ret = 0;
500 }
501 goto cleanup;
502 }
503
504 /*
505 * Create a shallow copy of `sought` so that we can free all of its entries.
506 * This is because `fetch_pack()` will modify the array to evict some
507 * entries, but won't free those.
508 */
509 DUP_ARRAY(to_fetch_dup, to_fetch, nr_heads);
510 to_fetch = to_fetch_dup;
511
512 refs = fetch_pack(&args, data->fd,
513 refs_tmp ? refs_tmp : transport->remote_refs,
514 to_fetch, nr_heads, &data->shallow,
515 &transport->pack_lockfiles, data->version);
516
517 data->finished_handshake = 0;
518 data->options.self_contained_and_connected =
519 args.self_contained_and_connected;
520 data->options.connectivity_checked = args.connectivity_checked;
521
522 if (!refs)
523 ret = -1;
524 if (report_unmatched_refs(to_fetch, nr_heads))
525 ret = -1;
526
527cleanup:
528 close(data->fd[0]);
529 if (data->fd[1] >= 0)
530 close(data->fd[1]);
531 if (finish_connect(data->conn))
532 ret = -1;
533 data->conn = NULL;
534
535 free(to_fetch_dup);
536 free_refs(refs_tmp);
537 free_refs(refs);
538 list_objects_filter_release(&args.filter_options);
539 return ret;
540}
541
542static int push_had_errors(struct ref *ref)
543{
544 for (; ref; ref = ref->next) {
545 switch (ref->status) {
546 case REF_STATUS_NONE:
547 case REF_STATUS_UPTODATE:
548 case REF_STATUS_OK:
549 break;
550 default:
551 return 1;
552 }
553 }
554 return 0;
555}
556
557int transport_refs_pushed(struct ref *ref)
558{
559 for (; ref; ref = ref->next) {
560 switch(ref->status) {
561 case REF_STATUS_NONE:
562 case REF_STATUS_UPTODATE:
563 break;
564 default:
565 return 1;
566 }
567 }
568 return 0;
569}
570
571static void update_one_tracking_ref(struct remote *remote, char *refname,
572 struct object_id *new_oid, int deletion,
573 int verbose)
574{
575 struct refspec_item rs;
576
577 memset(&rs, 0, sizeof(rs));
578 rs.src = refname;
579 rs.dst = NULL;
580
581 if (!remote_find_tracking(remote, &rs)) {
582 if (verbose)
583 fprintf(stderr, "updating local tracking ref '%s'\n", rs.dst);
584 if (deletion)
585 refs_delete_ref(get_main_ref_store(the_repository),
586 NULL, rs.dst, NULL, 0);
587 else
588 refs_update_ref(get_main_ref_store(the_repository),
589 "update by push", rs.dst, new_oid,
590 NULL, 0, 0);
591 free(rs.dst);
592 }
593}
594
595void transport_update_tracking_ref(struct remote *remote, struct ref *ref, int verbose)
596{
597 char *refname;
598 struct object_id *new_oid;
599 struct ref_push_report *report;
600
601 if (ref->status != REF_STATUS_OK && ref->status != REF_STATUS_UPTODATE)
602 return;
603
604 report = ref->report;
605 if (!report)
606 update_one_tracking_ref(remote, ref->name, &ref->new_oid,
607 ref->deletion, verbose);
608 else
609 for (; report; report = report->next) {
610 refname = report->ref_name ? (char *)report->ref_name : ref->name;
611 new_oid = report->new_oid ? report->new_oid : &ref->new_oid;
612 update_one_tracking_ref(remote, refname, new_oid,
613 is_null_oid(new_oid), verbose);
614 }
615}
616
617static void print_ref_status(char flag, const char *summary,
618 struct ref *to, struct ref *from, const char *msg,
619 struct ref_push_report *report,
620 int porcelain, int summary_width)
621{
622 const char *to_name;
623
624 if (report && report->ref_name)
625 to_name = report->ref_name;
626 else
627 to_name = to->name;
628
629 if (porcelain) {
630 if (from)
631 fprintf(stdout, "%c\t%s:%s\t", flag, from->name, to_name);
632 else
633 fprintf(stdout, "%c\t:%s\t", flag, to_name);
634 if (msg)
635 fprintf(stdout, "%s (%s)\n", summary, msg);
636 else
637 fprintf(stdout, "%s\n", summary);
638 } else {
639 const char *red = "", *reset = "";
640 if (push_had_errors(to)) {
641 red = transport_get_color(TRANSPORT_COLOR_REJECTED);
642 reset = transport_get_color(TRANSPORT_COLOR_RESET);
643 }
644 fprintf(stderr, " %s%c %-*s%s ", red, flag, summary_width,
645 summary, reset);
646 if (from)
647 fprintf(stderr, "%s -> %s",
648 prettify_refname(from->name),
649 prettify_refname(to_name));
650 else
651 fputs(prettify_refname(to_name), stderr);
652 if (msg) {
653 fputs(" (", stderr);
654 fputs(msg, stderr);
655 fputc(')', stderr);
656 }
657 fputc('\n', stderr);
658 }
659}
660
661static void print_ok_ref_status(struct ref *ref,
662 struct ref_push_report *report,
663 int porcelain, int summary_width)
664{
665 struct object_id *old_oid;
666 struct object_id *new_oid;
667 const char *ref_name;
668 int forced_update;
669
670 if (report && report->old_oid)
671 old_oid = report->old_oid;
672 else
673 old_oid = &ref->old_oid;
674 if (report && report->new_oid)
675 new_oid = report->new_oid;
676 else
677 new_oid = &ref->new_oid;
678 if (report && report->forced_update)
679 forced_update = report->forced_update;
680 else
681 forced_update = ref->forced_update;
682 if (report && report->ref_name)
683 ref_name = report->ref_name;
684 else
685 ref_name = ref->name;
686
687 if (ref->deletion)
688 print_ref_status('-', "[deleted]", ref, NULL, NULL,
689 report, porcelain, summary_width);
690 else if (is_null_oid(old_oid))
691 print_ref_status('*',
692 (starts_with(ref_name, "refs/tags/")
693 ? "[new tag]"
694 : (starts_with(ref_name, "refs/heads/")
695 ? "[new branch]"
696 : "[new reference]")),
697 ref, ref->peer_ref, NULL,
698 report, porcelain, summary_width);
699 else {
700 struct strbuf quickref = STRBUF_INIT;
701 char type;
702 const char *msg;
703
704 strbuf_add_unique_abbrev(&quickref, old_oid,
705 DEFAULT_ABBREV);
706 if (forced_update) {
707 strbuf_addstr(&quickref, "...");
708 type = '+';
709 msg = "forced update";
710 } else {
711 strbuf_addstr(&quickref, "..");
712 type = ' ';
713 msg = NULL;
714 }
715 strbuf_add_unique_abbrev(&quickref, new_oid,
716 DEFAULT_ABBREV);
717
718 print_ref_status(type, quickref.buf, ref, ref->peer_ref, msg,
719 report, porcelain, summary_width);
720 strbuf_release(&quickref);
721 }
722}
723
724static int print_one_push_report(struct ref *ref, const char *dest, int count,
725 struct ref_push_report *report,
726 int porcelain, int summary_width)
727{
728 if (!count) {
729 char *url = transport_anonymize_url(dest);
730 fprintf(porcelain ? stdout : stderr, "To %s\n", url);
731 free(url);
732 }
733
734 switch(ref->status) {
735 case REF_STATUS_NONE:
736 print_ref_status('X', "[no match]", ref, NULL, NULL,
737 report, porcelain, summary_width);
738 break;
739 case REF_STATUS_REJECT_NODELETE:
740 print_ref_status('!', "[rejected]", ref, NULL,
741 "remote does not support deleting refs",
742 report, porcelain, summary_width);
743 break;
744 case REF_STATUS_UPTODATE:
745 print_ref_status('=', "[up to date]", ref,
746 ref->peer_ref, NULL,
747 report, porcelain, summary_width);
748 break;
749 case REF_STATUS_REJECT_NONFASTFORWARD:
750 print_ref_status('!', "[rejected]", ref, ref->peer_ref,
751 "non-fast-forward",
752 report, porcelain, summary_width);
753 break;
754 case REF_STATUS_REJECT_ALREADY_EXISTS:
755 print_ref_status('!', "[rejected]", ref, ref->peer_ref,
756 "already exists",
757 report, porcelain, summary_width);
758 break;
759 case REF_STATUS_REJECT_FETCH_FIRST:
760 print_ref_status('!', "[rejected]", ref, ref->peer_ref,
761 "fetch first",
762 report, porcelain, summary_width);
763 break;
764 case REF_STATUS_REJECT_NEEDS_FORCE:
765 print_ref_status('!', "[rejected]", ref, ref->peer_ref,
766 "needs force",
767 report, porcelain, summary_width);
768 break;
769 case REF_STATUS_REJECT_STALE:
770 print_ref_status('!', "[rejected]", ref, ref->peer_ref,
771 "stale info",
772 report, porcelain, summary_width);
773 break;
774 case REF_STATUS_REJECT_REMOTE_UPDATED:
775 print_ref_status('!', "[rejected]", ref, ref->peer_ref,
776 "remote ref updated since checkout",
777 report, porcelain, summary_width);
778 break;
779 case REF_STATUS_REJECT_SHALLOW:
780 print_ref_status('!', "[rejected]", ref, ref->peer_ref,
781 "new shallow roots not allowed",
782 report, porcelain, summary_width);
783 break;
784 case REF_STATUS_REMOTE_REJECT:
785 print_ref_status('!', "[remote rejected]", ref,
786 ref->deletion ? NULL : ref->peer_ref,
787 ref->remote_status,
788 report, porcelain, summary_width);
789 break;
790 case REF_STATUS_EXPECTING_REPORT:
791 print_ref_status('!', "[remote failure]", ref,
792 ref->deletion ? NULL : ref->peer_ref,
793 "remote failed to report status",
794 report, porcelain, summary_width);
795 break;
796 case REF_STATUS_ATOMIC_PUSH_FAILED:
797 print_ref_status('!', "[rejected]", ref, ref->peer_ref,
798 "atomic push failed",
799 report, porcelain, summary_width);
800 break;
801 case REF_STATUS_OK:
802 print_ok_ref_status(ref, report, porcelain, summary_width);
803 break;
804 }
805
806 return 1;
807}
808
809static int print_one_push_status(struct ref *ref, const char *dest, int count,
810 int porcelain, int summary_width)
811{
812 struct ref_push_report *report;
813 int n = 0;
814
815 if (!ref->report)
816 return print_one_push_report(ref, dest, count,
817 NULL, porcelain, summary_width);
818
819 for (report = ref->report; report; report = report->next)
820 print_one_push_report(ref, dest, count + n++,
821 report, porcelain, summary_width);
822 return n;
823}
824
825static int measure_abbrev(const struct object_id *oid, int sofar)
826{
827 char hex[GIT_MAX_HEXSZ + 1];
828 int w = repo_find_unique_abbrev_r(the_repository, hex, oid,
829 DEFAULT_ABBREV);
830
831 return (w < sofar) ? sofar : w;
832}
833
834int transport_summary_width(const struct ref *refs)
835{
836 int maxw = -1;
837
838 for (; refs; refs = refs->next) {
839 maxw = measure_abbrev(&refs->old_oid, maxw);
840 maxw = measure_abbrev(&refs->new_oid, maxw);
841 }
842 if (maxw < 0)
843 maxw = FALLBACK_DEFAULT_ABBREV;
844 return (2 * maxw + 3);
845}
846
847void transport_print_push_status(const char *dest, struct ref *refs,
848 int verbose, int porcelain, unsigned int *reject_reasons)
849{
850 struct ref *ref;
851 int n = 0;
852 char *head;
853 int summary_width = transport_summary_width(refs);
854
855 if (transport_color_config() < 0)
856 warning(_("could not parse transport.color.* config"));
857
858 head = refs_resolve_refdup(get_main_ref_store(the_repository), "HEAD",
859 RESOLVE_REF_READING, NULL, NULL);
860
861 if (verbose) {
862 for (ref = refs; ref; ref = ref->next)
863 if (ref->status == REF_STATUS_UPTODATE)
864 n += print_one_push_status(ref, dest, n,
865 porcelain, summary_width);
866 }
867
868 for (ref = refs; ref; ref = ref->next)
869 if (ref->status == REF_STATUS_OK)
870 n += print_one_push_status(ref, dest, n,
871 porcelain, summary_width);
872
873 *reject_reasons = 0;
874 for (ref = refs; ref; ref = ref->next) {
875 if (ref->status != REF_STATUS_NONE &&
876 ref->status != REF_STATUS_UPTODATE &&
877 ref->status != REF_STATUS_OK)
878 n += print_one_push_status(ref, dest, n,
879 porcelain, summary_width);
880 if (ref->status == REF_STATUS_REJECT_NONFASTFORWARD) {
881 if (head != NULL && !strcmp(head, ref->name))
882 *reject_reasons |= REJECT_NON_FF_HEAD;
883 else
884 *reject_reasons |= REJECT_NON_FF_OTHER;
885 } else if (ref->status == REF_STATUS_REJECT_ALREADY_EXISTS) {
886 *reject_reasons |= REJECT_ALREADY_EXISTS;
887 } else if (ref->status == REF_STATUS_REJECT_FETCH_FIRST) {
888 *reject_reasons |= REJECT_FETCH_FIRST;
889 } else if (ref->status == REF_STATUS_REJECT_NEEDS_FORCE) {
890 *reject_reasons |= REJECT_NEEDS_FORCE;
891 } else if (ref->status == REF_STATUS_REJECT_REMOTE_UPDATED) {
892 *reject_reasons |= REJECT_REF_NEEDS_UPDATE;
893 }
894 }
895 free(head);
896}
897
898static int git_transport_push(struct transport *transport, struct ref *remote_refs, int flags)
899{
900 struct git_transport_data *data = transport->data;
901 struct send_pack_args args;
902 int ret = 0;
903
904 if (transport_color_config() < 0)
905 return -1;
906
907 if (!data->finished_handshake)
908 get_refs_via_connect(transport, 1, NULL);
909
910 memset(&args, 0, sizeof(args));
911 args.send_mirror = !!(flags & TRANSPORT_PUSH_MIRROR);
912 args.force_update = !!(flags & TRANSPORT_PUSH_FORCE);
913 args.use_thin_pack = data->options.thin;
914 args.verbose = (transport->verbose > 0);
915 args.quiet = (transport->verbose < 0);
916 args.progress = transport->progress;
917 args.dry_run = !!(flags & TRANSPORT_PUSH_DRY_RUN);
918 args.porcelain = !!(flags & TRANSPORT_PUSH_PORCELAIN);
919 args.atomic = !!(flags & TRANSPORT_PUSH_ATOMIC);
920 args.push_options = transport->push_options;
921 args.url = transport->url;
922
923 if (flags & TRANSPORT_PUSH_CERT_ALWAYS)
924 args.push_cert = SEND_PACK_PUSH_CERT_ALWAYS;
925 else if (flags & TRANSPORT_PUSH_CERT_IF_ASKED)
926 args.push_cert = SEND_PACK_PUSH_CERT_IF_ASKED;
927 else
928 args.push_cert = SEND_PACK_PUSH_CERT_NEVER;
929
930 switch (data->version) {
931 case protocol_v2:
932 die(_("support for protocol v2 not implemented yet"));
933 break;
934 case protocol_v1:
935 case protocol_v0:
936 ret = send_pack(the_repository, &args, data->fd, data->conn, remote_refs,
937 &data->extra_have);
938 /*
939 * Ignore the specific error code to maintain consistent behavior
940 * with the "push_refs()" function across different transports,
941 * such as "push_refs_with_push()" for HTTP protocol.
942 */
943 if (ret == ERROR_SEND_PACK_BAD_REF_STATUS)
944 ret = 0;
945 break;
946 case protocol_unknown_version:
947 BUG("unknown protocol version");
948 }
949
950 close(data->fd[1]);
951 close(data->fd[0]);
952 ret |= finish_connect(data->conn);
953 data->conn = NULL;
954 data->finished_handshake = 0;
955
956 return ret;
957}
958
959static int connect_git(struct transport *transport, const char *name,
960 const char *executable, int fd[2])
961{
962 struct git_transport_data *data = transport->data;
963 data->conn = git_connect(data->fd, transport->url,
964 name, executable, 0);
965 fd[0] = data->fd[0];
966 fd[1] = data->fd[1];
967 return 0;
968}
969
970static int disconnect_git(struct transport *transport)
971{
972 struct git_transport_data *data = transport->data;
973 if (data->conn) {
974 if (data->finished_handshake && !transport->stateless_rpc)
975 packet_flush(data->fd[1]);
976 close(data->fd[0]);
977 if (data->fd[1] >= 0)
978 close(data->fd[1]);
979 finish_connect(data->conn);
980 }
981
982 if (data->options.negotiation_tips) {
983 oid_array_clear(data->options.negotiation_tips);
984 free(data->options.negotiation_tips);
985 }
986 list_objects_filter_release(&data->options.filter_options);
987 oid_array_clear(&data->extra_have);
988 oid_array_clear(&data->shallow);
989 free(data);
990 return 0;
991}
992
993static struct transport_vtable taken_over_vtable = {
994 .get_refs_list = get_refs_via_connect,
995 .get_bundle_uri = get_bundle_uri,
996 .fetch_refs = fetch_refs_via_pack,
997 .push_refs = git_transport_push,
998 .disconnect = disconnect_git
999};
1000
1001void transport_take_over(struct transport *transport,
1002 struct child_process *child)
1003{
1004 struct git_transport_data *data;
1005
1006 if (!transport->smart_options)
1007 BUG("taking over transport requires non-NULL "
1008 "smart_options field.");
1009
1010 CALLOC_ARRAY(data, 1);
1011 data->options = *transport->smart_options;
1012 data->conn = child;
1013 data->fd[0] = data->conn->out;
1014 data->fd[1] = data->conn->in;
1015 data->finished_handshake = 0;
1016 transport->data = data;
1017
1018 transport->vtable = &taken_over_vtable;
1019 transport->smart_options = &(data->options);
1020
1021 transport->cannot_reuse = 1;
1022}
1023
1024static int is_file(const char *url)
1025{
1026 struct stat buf;
1027 if (stat(url, &buf))
1028 return 0;
1029 return S_ISREG(buf.st_mode);
1030}
1031
1032static int external_specification_len(const char *url)
1033{
1034 return strchr(url, ':') - url;
1035}
1036
1037static const struct string_list *protocol_allow_list(void)
1038{
1039 static int enabled = -1;
1040 static struct string_list allowed = STRING_LIST_INIT_DUP;
1041
1042 if (enabled < 0) {
1043 const char *v = getenv("GIT_ALLOW_PROTOCOL");
1044 if (v) {
1045 string_list_split(&allowed, v, ":", -1);
1046 string_list_sort(&allowed);
1047 enabled = 1;
1048 } else {
1049 enabled = 0;
1050 }
1051 }
1052
1053 return enabled ? &allowed : NULL;
1054}
1055
1056enum protocol_allow_config {
1057 PROTOCOL_ALLOW_NEVER = 0,
1058 PROTOCOL_ALLOW_USER_ONLY,
1059 PROTOCOL_ALLOW_ALWAYS
1060};
1061
1062static enum protocol_allow_config parse_protocol_config(const char *key,
1063 const char *value)
1064{
1065 if (!strcasecmp(value, "always"))
1066 return PROTOCOL_ALLOW_ALWAYS;
1067 else if (!strcasecmp(value, "never"))
1068 return PROTOCOL_ALLOW_NEVER;
1069 else if (!strcasecmp(value, "user"))
1070 return PROTOCOL_ALLOW_USER_ONLY;
1071
1072 die(_("unknown value for config '%s': %s"), key, value);
1073}
1074
1075static enum protocol_allow_config get_protocol_config(const char *type)
1076{
1077 char *key = xstrfmt("protocol.%s.allow", type);
1078 char *value;
1079
1080 /* first check the per-protocol config */
1081 if (!repo_config_get_string(the_repository, key, &value)) {
1082 enum protocol_allow_config ret =
1083 parse_protocol_config(key, value);
1084 free(key);
1085 free(value);
1086 return ret;
1087 }
1088 free(key);
1089
1090 /* if defined, fallback to user-defined default for unknown protocols */
1091 if (!repo_config_get_string(the_repository, "protocol.allow", &value)) {
1092 enum protocol_allow_config ret =
1093 parse_protocol_config("protocol.allow", value);
1094 free(value);
1095 return ret;
1096 }
1097
1098 /* fallback to built-in defaults */
1099 /* known safe */
1100 if (!strcmp(type, "http") ||
1101 !strcmp(type, "https") ||
1102 !strcmp(type, "git") ||
1103 !strcmp(type, "ssh"))
1104 return PROTOCOL_ALLOW_ALWAYS;
1105
1106 /* known scary; err on the side of caution */
1107 if (!strcmp(type, "ext"))
1108 return PROTOCOL_ALLOW_NEVER;
1109
1110 /* unknown; by default let them be used only directly by the user */
1111 return PROTOCOL_ALLOW_USER_ONLY;
1112}
1113
1114int is_transport_allowed(const char *type, int from_user)
1115{
1116 const struct string_list *allow_list = protocol_allow_list();
1117 if (allow_list)
1118 return string_list_has_string(allow_list, type);
1119
1120 switch (get_protocol_config(type)) {
1121 case PROTOCOL_ALLOW_ALWAYS:
1122 return 1;
1123 case PROTOCOL_ALLOW_NEVER:
1124 return 0;
1125 case PROTOCOL_ALLOW_USER_ONLY:
1126 if (from_user < 0)
1127 from_user = git_env_bool("GIT_PROTOCOL_FROM_USER", 1);
1128 return from_user;
1129 }
1130
1131 BUG("invalid protocol_allow_config type");
1132}
1133
1134int parse_transport_option(const char *var, const char *value,
1135 struct string_list *transport_options)
1136{
1137 if (!value)
1138 return config_error_nonbool(var);
1139 if (!*value)
1140 string_list_clear(transport_options, 0);
1141 else
1142 string_list_append(transport_options, value);
1143 return 0;
1144}
1145
1146void transport_check_allowed(const char *type)
1147{
1148 if (!is_transport_allowed(type, -1))
1149 die(_("transport '%s' not allowed"), type);
1150}
1151
1152static struct transport_vtable bundle_vtable = {
1153 .get_refs_list = get_refs_from_bundle,
1154 .fetch_refs = fetch_refs_from_bundle,
1155 .disconnect = close_bundle
1156};
1157
1158static struct transport_vtable builtin_smart_vtable = {
1159 .get_refs_list = get_refs_via_connect,
1160 .get_bundle_uri = get_bundle_uri,
1161 .fetch_refs = fetch_refs_via_pack,
1162 .push_refs = git_transport_push,
1163 .connect = connect_git,
1164 .disconnect = disconnect_git
1165};
1166
1167struct transport *transport_get(struct remote *remote, const char *url)
1168{
1169 const char *helper;
1170 char *helper_to_free = NULL;
1171 const char *p;
1172 struct transport *ret = xcalloc(1, sizeof(*ret));
1173
1174 ret->progress = isatty(2);
1175 string_list_init_dup(&ret->pack_lockfiles);
1176
1177 CALLOC_ARRAY(ret->bundles, 1);
1178 init_bundle_list(ret->bundles);
1179
1180 if (!remote)
1181 BUG("No remote provided to transport_get()");
1182
1183 ret->got_remote_refs = 0;
1184 ret->remote = remote;
1185 helper = remote->foreign_vcs;
1186
1187 if (!url)
1188 url = remote->url.v[0];
1189 ret->url = url;
1190
1191 p = url;
1192 while (is_urlschemechar(p == url, *p))
1193 p++;
1194 if (starts_with(p, "::"))
1195 helper = helper_to_free = xstrndup(url, p - url);
1196
1197 if (helper) {
1198 transport_helper_init(ret, helper);
1199 free(helper_to_free);
1200 } else if (starts_with(url, "rsync:")) {
1201 die(_("git-over-rsync is no longer supported"));
1202 } else if (url_is_local_not_ssh(url) && is_file(url) && is_bundle(url, 1)) {
1203 struct bundle_transport_data *data = xcalloc(1, sizeof(*data));
1204 bundle_header_init(&data->header);
1205 transport_check_allowed("file");
1206 ret->data = data;
1207 ret->vtable = &bundle_vtable;
1208 ret->smart_options = NULL;
1209 } else if (!is_url(url)
1210 || starts_with(url, "file://")
1211 || starts_with(url, "git://")
1212 || starts_with(url, "ssh://")
1213 || starts_with(url, "git+ssh://") /* deprecated - do not use */
1214 || starts_with(url, "ssh+git://") /* deprecated - do not use */
1215 ) {
1216 /*
1217 * These are builtin smart transports; "allowed" transports
1218 * will be checked individually in git_connect.
1219 */
1220 struct git_transport_data *data = xcalloc(1, sizeof(*data));
1221 list_objects_filter_init(&data->options.filter_options);
1222 ret->data = data;
1223 ret->vtable = &builtin_smart_vtable;
1224 ret->smart_options = &(data->options);
1225
1226 data->conn = NULL;
1227 data->finished_handshake = 0;
1228 } else {
1229 /* Unknown protocol in URL. Pass to external handler. */
1230 int len = external_specification_len(url);
1231 char *handler = xmemdupz(url, len);
1232 transport_helper_init(ret, handler);
1233 free(handler);
1234 }
1235
1236 if (ret->smart_options) {
1237 ret->smart_options->thin = 1;
1238 ret->smart_options->uploadpack = "git-upload-pack";
1239 if (remote->uploadpack)
1240 ret->smart_options->uploadpack = remote->uploadpack;
1241 ret->smart_options->receivepack = "git-receive-pack";
1242 if (remote->receivepack)
1243 ret->smart_options->receivepack = remote->receivepack;
1244 }
1245
1246 ret->hash_algo = &hash_algos[GIT_HASH_SHA1_LEGACY];
1247
1248 return ret;
1249}
1250
1251const struct git_hash_algo *transport_get_hash_algo(struct transport *transport)
1252{
1253 return transport->hash_algo;
1254}
1255
1256int transport_set_option(struct transport *transport,
1257 const char *name, const char *value)
1258{
1259 int git_reports = 1, protocol_reports = 1;
1260
1261 if (transport->smart_options)
1262 git_reports = set_git_option(transport->smart_options,
1263 name, value);
1264
1265 if (transport->vtable->set_option)
1266 protocol_reports = transport->vtable->set_option(transport,
1267 name, value);
1268
1269 /* If either report is 0, report 0 (success). */
1270 if (!git_reports || !protocol_reports)
1271 return 0;
1272 /* If either reports -1 (invalid value), report -1. */
1273 if ((git_reports == -1) || (protocol_reports == -1))
1274 return -1;
1275 /* Otherwise if both report unknown, report unknown. */
1276 return 1;
1277}
1278
1279void transport_set_verbosity(struct transport *transport, int verbosity,
1280 int force_progress)
1281{
1282 if (verbosity >= 1)
1283 transport->verbose = verbosity <= 3 ? verbosity : 3;
1284 if (verbosity < 0)
1285 transport->verbose = -1;
1286
1287 /**
1288 * Rules used to determine whether to report progress (processing aborts
1289 * when a rule is satisfied):
1290 *
1291 * . Report progress, if force_progress is 1 (ie. --progress).
1292 * . Don't report progress, if force_progress is 0 (ie. --no-progress).
1293 * . Don't report progress, if verbosity < 0 (ie. -q/--quiet ).
1294 * . Report progress if isatty(2) is 1.
1295 **/
1296 if (force_progress >= 0)
1297 transport->progress = !!force_progress;
1298 else
1299 transport->progress = verbosity >= 0 && isatty(2);
1300}
1301
1302static void die_with_unpushed_submodules(struct string_list *needs_pushing)
1303{
1304 fprintf(stderr, _("The following submodule paths contain changes that can\n"
1305 "not be found on any remote:\n"));
1306 for (size_t i = 0; i < needs_pushing->nr; i++)
1307 fprintf(stderr, " %s\n", needs_pushing->items[i].string);
1308 fprintf(stderr, _("\nPlease try\n\n"
1309 " git push --recurse-submodules=on-demand\n\n"
1310 "or cd to the path and use\n\n"
1311 " git push\n\n"
1312 "to push them to a remote.\n\n"));
1313
1314 string_list_clear(needs_pushing, 0);
1315
1316 die(_("Aborting."));
1317}
1318
1319static int run_pre_push_hook(struct transport *transport,
1320 struct ref *remote_refs)
1321{
1322 int ret = 0, x;
1323 struct ref *r;
1324 struct child_process proc = CHILD_PROCESS_INIT;
1325 struct strbuf buf;
1326 const char *hook_path = find_hook(the_repository, "pre-push");
1327
1328 if (!hook_path)
1329 return 0;
1330
1331 strvec_push(&proc.args, hook_path);
1332 strvec_push(&proc.args, transport->remote->name);
1333 strvec_push(&proc.args, transport->url);
1334
1335 proc.in = -1;
1336 proc.trace2_hook_name = "pre-push";
1337
1338 if (start_command(&proc)) {
1339 finish_command(&proc);
1340 return -1;
1341 }
1342
1343 sigchain_push(SIGPIPE, SIG_IGN);
1344
1345 strbuf_init(&buf, 256);
1346
1347 for (r = remote_refs; r; r = r->next) {
1348 if (!r->peer_ref) continue;
1349 if (r->status == REF_STATUS_REJECT_NONFASTFORWARD) continue;
1350 if (r->status == REF_STATUS_REJECT_STALE) continue;
1351 if (r->status == REF_STATUS_REJECT_REMOTE_UPDATED) continue;
1352 if (r->status == REF_STATUS_UPTODATE) continue;
1353
1354 strbuf_reset(&buf);
1355 strbuf_addf( &buf, "%s %s %s %s\n",
1356 r->peer_ref->name, oid_to_hex(&r->new_oid),
1357 r->name, oid_to_hex(&r->old_oid));
1358
1359 if (write_in_full(proc.in, buf.buf, buf.len) < 0) {
1360 /* We do not mind if a hook does not read all refs. */
1361 if (errno != EPIPE)
1362 ret = -1;
1363 break;
1364 }
1365 }
1366
1367 strbuf_release(&buf);
1368
1369 x = close(proc.in);
1370 if (!ret)
1371 ret = x;
1372
1373 sigchain_pop(SIGPIPE);
1374
1375 x = finish_command(&proc);
1376 if (!ret)
1377 ret = x;
1378
1379 return ret;
1380}
1381
1382int transport_push(struct repository *r,
1383 struct transport *transport,
1384 struct refspec *rs, int flags,
1385 unsigned int *reject_reasons)
1386{
1387 struct ref *remote_refs = NULL;
1388 struct ref *local_refs = NULL;
1389 int match_flags = MATCH_REFS_NONE;
1390 int verbose = (transport->verbose > 0);
1391 int quiet = (transport->verbose < 0);
1392 int porcelain = flags & TRANSPORT_PUSH_PORCELAIN;
1393 int pretend = flags & TRANSPORT_PUSH_DRY_RUN;
1394 int push_ret, err;
1395 int ret = -1;
1396 struct transport_ls_refs_options transport_options =
1397 TRANSPORT_LS_REFS_OPTIONS_INIT;
1398
1399 *reject_reasons = 0;
1400
1401 if (transport_color_config() < 0)
1402 goto done;
1403
1404 if (!transport->vtable->push_refs)
1405 goto done;
1406
1407 local_refs = get_local_heads();
1408
1409 if (check_push_refs(local_refs, rs) < 0)
1410 goto done;
1411
1412 refspec_ref_prefixes(rs, &transport_options.ref_prefixes);
1413
1414 trace2_region_enter("transport_push", "get_refs_list", r);
1415 remote_refs = transport->vtable->get_refs_list(transport, 1,
1416 &transport_options);
1417 trace2_region_leave("transport_push", "get_refs_list", r);
1418
1419 transport_ls_refs_options_release(&transport_options);
1420
1421 if (flags & TRANSPORT_PUSH_ALL)
1422 match_flags |= MATCH_REFS_ALL;
1423 if (flags & TRANSPORT_PUSH_MIRROR)
1424 match_flags |= MATCH_REFS_MIRROR;
1425 if (flags & TRANSPORT_PUSH_PRUNE)
1426 match_flags |= MATCH_REFS_PRUNE;
1427 if (flags & TRANSPORT_PUSH_FOLLOW_TAGS)
1428 match_flags |= MATCH_REFS_FOLLOW_TAGS;
1429
1430 if (match_push_refs(local_refs, &remote_refs, rs, match_flags))
1431 goto done;
1432
1433 if (transport->smart_options &&
1434 transport->smart_options->cas &&
1435 !is_empty_cas(transport->smart_options->cas))
1436 apply_push_cas(transport->smart_options->cas,
1437 transport->remote, remote_refs);
1438
1439 set_ref_status_for_push(remote_refs,
1440 flags & TRANSPORT_PUSH_MIRROR,
1441 flags & TRANSPORT_PUSH_FORCE);
1442
1443 if (!(flags & TRANSPORT_PUSH_NO_HOOK))
1444 if (run_pre_push_hook(transport, remote_refs))
1445 goto done;
1446
1447 if ((flags & (TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND |
1448 TRANSPORT_RECURSE_SUBMODULES_ONLY)) &&
1449 !is_bare_repository()) {
1450 struct ref *ref = remote_refs;
1451 struct oid_array commits = OID_ARRAY_INIT;
1452
1453 trace2_region_enter("transport_push", "push_submodules", r);
1454 for (; ref; ref = ref->next)
1455 if (!is_null_oid(&ref->new_oid))
1456 oid_array_append(&commits,
1457 &ref->new_oid);
1458
1459 if (!push_unpushed_submodules(r,
1460 &commits,
1461 transport->remote,
1462 rs,
1463 transport->push_options,
1464 pretend)) {
1465 oid_array_clear(&commits);
1466 trace2_region_leave("transport_push", "push_submodules", r);
1467 die(_("failed to push all needed submodules"));
1468 }
1469 oid_array_clear(&commits);
1470 trace2_region_leave("transport_push", "push_submodules", r);
1471 }
1472
1473 if (((flags & TRANSPORT_RECURSE_SUBMODULES_CHECK) ||
1474 ((flags & (TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND |
1475 TRANSPORT_RECURSE_SUBMODULES_ONLY)) &&
1476 !pretend)) && !is_bare_repository()) {
1477 struct ref *ref = remote_refs;
1478 struct string_list needs_pushing = STRING_LIST_INIT_DUP;
1479 struct oid_array commits = OID_ARRAY_INIT;
1480
1481 trace2_region_enter("transport_push", "check_submodules", r);
1482 for (; ref; ref = ref->next)
1483 if (!is_null_oid(&ref->new_oid))
1484 oid_array_append(&commits,
1485 &ref->new_oid);
1486
1487 if (find_unpushed_submodules(r,
1488 &commits,
1489 transport->remote->name,
1490 &needs_pushing)) {
1491 oid_array_clear(&commits);
1492 trace2_region_leave("transport_push", "check_submodules", r);
1493 die_with_unpushed_submodules(&needs_pushing);
1494 }
1495 string_list_clear(&needs_pushing, 0);
1496 oid_array_clear(&commits);
1497 trace2_region_leave("transport_push", "check_submodules", r);
1498 }
1499
1500 if (!(flags & TRANSPORT_RECURSE_SUBMODULES_ONLY)) {
1501 trace2_region_enter("transport_push", "push_refs", r);
1502 push_ret = transport->vtable->push_refs(transport, remote_refs, flags);
1503 trace2_region_leave("transport_push", "push_refs", r);
1504 } else
1505 push_ret = 0;
1506 err = push_had_errors(remote_refs);
1507 ret = push_ret | err;
1508
1509 if (!quiet || err)
1510 transport_print_push_status(transport->url, remote_refs,
1511 verbose | porcelain, porcelain,
1512 reject_reasons);
1513
1514 if (flags & TRANSPORT_PUSH_SET_UPSTREAM)
1515 set_upstreams(transport, remote_refs, pretend);
1516
1517 if (!(flags & (TRANSPORT_PUSH_DRY_RUN |
1518 TRANSPORT_RECURSE_SUBMODULES_ONLY))) {
1519 struct ref *ref;
1520 for (ref = remote_refs; ref; ref = ref->next)
1521 transport_update_tracking_ref(transport->remote, ref, verbose);
1522 }
1523
1524 if (porcelain && !push_ret)
1525 puts("Done");
1526 else if (!quiet && !ret && !transport_refs_pushed(remote_refs))
1527 /* stable plumbing output; do not modify or localize */
1528 fprintf(stderr, "Everything up-to-date\n");
1529
1530done:
1531 free_refs(local_refs);
1532 free_refs(remote_refs);
1533 return ret;
1534}
1535
1536const struct ref *transport_get_remote_refs(struct transport *transport,
1537 struct transport_ls_refs_options *transport_options)
1538{
1539 if (!transport->got_remote_refs) {
1540 transport->remote_refs =
1541 transport->vtable->get_refs_list(transport, 0,
1542 transport_options);
1543 transport->got_remote_refs = 1;
1544 }
1545
1546 return transport->remote_refs;
1547}
1548
1549void transport_ls_refs_options_release(struct transport_ls_refs_options *opts)
1550{
1551 strvec_clear(&opts->ref_prefixes);
1552 free((char *)opts->unborn_head_target);
1553}
1554
1555int transport_fetch_refs(struct transport *transport, struct ref *refs)
1556{
1557 int rc;
1558 int nr_heads = 0, nr_alloc = 0, nr_refs = 0;
1559 struct ref **heads = NULL;
1560 struct ref *rm;
1561
1562 for (rm = refs; rm; rm = rm->next) {
1563 nr_refs++;
1564 if (rm->peer_ref &&
1565 !is_null_oid(&rm->old_oid) &&
1566 oideq(&rm->peer_ref->old_oid, &rm->old_oid))
1567 continue;
1568 ALLOC_GROW(heads, nr_heads + 1, nr_alloc);
1569 heads[nr_heads++] = rm;
1570 }
1571
1572 if (!nr_heads) {
1573 /*
1574 * When deepening of a shallow repository is requested,
1575 * then local and remote refs are likely to still be equal.
1576 * Just feed them all to the fetch method in that case.
1577 * This condition shouldn't be met in a non-deepening fetch
1578 * (see builtin/fetch.c:quickfetch()).
1579 */
1580 ALLOC_ARRAY(heads, nr_refs);
1581 for (rm = refs; rm; rm = rm->next)
1582 heads[nr_heads++] = rm;
1583 }
1584
1585 rc = transport->vtable->fetch_refs(transport, nr_heads, heads);
1586
1587 free(heads);
1588 return rc;
1589}
1590
1591int transport_get_remote_bundle_uri(struct transport *transport)
1592{
1593 int value = 0;
1594 const struct transport_vtable *vtable = transport->vtable;
1595
1596 /* Check config only once. */
1597 if (transport->got_remote_bundle_uri)
1598 return 0;
1599 transport->got_remote_bundle_uri = 1;
1600
1601 /*
1602 * Don't request bundle-uri from the server unless configured to
1603 * do so by the transfer.bundleURI=true config option.
1604 */
1605 if (repo_config_get_bool(the_repository, "transfer.bundleuri", &value) || !value)
1606 return 0;
1607
1608 if (!transport->bundles->baseURI)
1609 transport->bundles->baseURI = xstrdup(transport->url);
1610
1611 if (!vtable->get_bundle_uri)
1612 return error(_("bundle-uri operation not supported by protocol"));
1613
1614 if (vtable->get_bundle_uri(transport) < 0)
1615 return error(_("could not retrieve server-advertised bundle-uri list"));
1616 return 0;
1617}
1618
1619void transport_unlock_pack(struct transport *transport, unsigned int flags)
1620{
1621 int in_signal_handler = !!(flags & TRANSPORT_UNLOCK_PACK_IN_SIGNAL_HANDLER);
1622
1623 for (size_t i = 0; i < transport->pack_lockfiles.nr; i++)
1624 if (in_signal_handler)
1625 unlink(transport->pack_lockfiles.items[i].string);
1626 else
1627 unlink_or_warn(transport->pack_lockfiles.items[i].string);
1628 if (!in_signal_handler)
1629 string_list_clear(&transport->pack_lockfiles, 0);
1630}
1631
1632int transport_connect(struct transport *transport, const char *name,
1633 const char *exec, int fd[2])
1634{
1635 if (transport->vtable->connect)
1636 return transport->vtable->connect(transport, name, exec, fd);
1637 else
1638 die(_("operation not supported by protocol"));
1639}
1640
1641int transport_disconnect(struct transport *transport)
1642{
1643 int ret = 0;
1644 if (transport->vtable->disconnect)
1645 ret = transport->vtable->disconnect(transport);
1646 if (transport->got_remote_refs)
1647 free_refs((void *)transport->remote_refs);
1648 clear_bundle_list(transport->bundles);
1649 free(transport->bundles);
1650 free(transport);
1651 return ret;
1652}
1653
1654/*
1655 * Strip username (and password) from a URL and return
1656 * it in a newly allocated string.
1657 */
1658char *transport_anonymize_url(const char *url)
1659{
1660 char *scheme_prefix, *anon_part;
1661 size_t anon_len, prefix_len = 0;
1662
1663 anon_part = strchr(url, '@');
1664 if (url_is_local_not_ssh(url) || !anon_part)
1665 goto literal_copy;
1666
1667 anon_len = strlen(++anon_part);
1668 scheme_prefix = strstr(url, "://");
1669 if (!scheme_prefix) {
1670 if (!strchr(anon_part, ':'))
1671 /* cannot be "me@there:/path/name" */
1672 goto literal_copy;
1673 } else {
1674 const char *cp;
1675 /* make sure scheme is reasonable */
1676 for (cp = url; cp < scheme_prefix; cp++) {
1677 switch (*cp) {
1678 /* RFC 1738 2.1 */
1679 case '+': case '.': case '-':
1680 break; /* ok */
1681 default:
1682 if (isalnum(*cp))
1683 break;
1684 /* it isn't */
1685 goto literal_copy;
1686 }
1687 }
1688 /* @ past the first slash does not count */
1689 cp = strchr(scheme_prefix + 3, '/');
1690 if (cp && cp < anon_part)
1691 goto literal_copy;
1692 prefix_len = scheme_prefix - url + 3;
1693 }
1694 return xstrfmt("%.*s%.*s", (int)prefix_len, url,
1695 (int)anon_len, anon_part);
1696literal_copy:
1697 return xstrdup(url);
1698}