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