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