🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v2.43.1 / . / connect.c
blob: 0d77737a5363c39fd71376c0f483bc8808538754 [file] [log] [blame]
Jason Riedy731043f2006-01-25 20:38:36[diff] [blame]1#include "git-compat-util.h"
Brandon Williamsb2141fc2017-06-14 18:07:36[diff] [blame]2#include "config.h"
Elijah Newren32a8f512023-03-21 06:26:03[diff] [blame]3#include "environment.h"
Elijah Newrenf394e092023-03-21 06:25:54[diff] [blame]4#include "gettext.h"
Elijah Newren41771fa2023-02-24 00:09:27[diff] [blame]5#include "hex.h"
Linus Torvalds41cb7482005-07-05 22:44:09[diff] [blame]6#include "pkt-line.h"
Junio C Hamanob10d0ec2005-07-08 07:02:52[diff] [blame]7#include "quote.h"
Junio C Hamano6abf5c02005-10-16 07:25:26[diff] [blame]8#include "refs.h"
Shawn O. Pearce15a1c0122007-03-12 23:00:19[diff] [blame]9#include "run-command.h"
Daniel Barkalow6b628162007-05-12 15:45:59[diff] [blame]10#include "remote.h"
Junio C Hamano47a59182013-07-08 20:56:53[diff] [blame]11#include "connect.h"
Jeff King9d2e9422010-05-23 09:19:44[diff] [blame]12#include "url.h"
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]13#include "string-list.h"
Jeff Kingfe299ec2020-03-30 14:03:46[diff] [blame]14#include "oid-array.h"
Elijah Newrenc3399322023-05-16 06:33:59[diff] [blame]15#include "path.h"
Jeff Kinga5adace2015-09-16 17:12:52[diff] [blame]16#include "transport.h"
Elijah Newren74ea5c92023-04-11 03:00:38[diff] [blame]17#include "trace2.h"
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]18#include "strbuf.h"
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]19#include "version.h"
Brandon Williams26090432017-10-16 17:55:27[diff] [blame]20#include "protocol.h"
Nguyễn Thái Ngọc Duy65b5f942018-05-20 18:40:06[diff] [blame]21#include "alias.h"
Ævar Arnfjörð Bjarmason0cfde742022-12-22 15:14:09[diff] [blame]22#include "bundle-uri.h"
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]23
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]24static char *server_capabilities_v1;
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]25static struct strvec server_capabilities_v2 = STRVEC_INIT;
Jeff King7ce4c8f2023-04-14 21:25:20[diff] [blame]26static const char *next_server_feature_value(const char *feature, size_t *len, size_t *offset);
Johannes Schindelin211b5f92005-10-28 02:48:54[diff] [blame]27
René Scharfebe0b3f82014-08-30 09:46:54[diff] [blame]28static int check_ref(const char *name, unsigned int flags)
Linus Torvalds2718ff02006-07-04 19:29:10[diff] [blame]29{
30 if (!flags)
31 return 1;
32
René Scharfebe0b3f82014-08-30 09:46:54[diff] [blame]33 if (!skip_prefix(name, "refs/", &name))
Linus Torvalds2718ff02006-07-04 19:29:10[diff] [blame]34 return 0;
35
Linus Torvalds2718ff02006-07-04 19:29:10[diff] [blame]36 /* REF_NORMAL means that we don't want the magic fake tag refs */
ZheNing Hu7c3c5502023-03-01 10:20:29[diff] [blame]37 if ((flags & REF_NORMAL) && check_refname_format(name,
38 REFNAME_ALLOW_ONELEVEL))
Linus Torvalds2718ff02006-07-04 19:29:10[diff] [blame]39 return 0;
40
41 /* REF_HEADS means that we want regular branch heads */
René Scharfebe0b3f82014-08-30 09:46:54[diff] [blame]42 if ((flags & REF_HEADS) && starts_with(name, "heads/"))
Linus Torvalds2718ff02006-07-04 19:29:10[diff] [blame]43 return 1;
44
45 /* REF_TAGS means that we want tags */
René Scharfebe0b3f82014-08-30 09:46:54[diff] [blame]46 if ((flags & REF_TAGS) && starts_with(name, "tags/"))
Linus Torvalds2718ff02006-07-04 19:29:10[diff] [blame]47 return 1;
48
49 /* All type bits clear means that we are ok with anything */
50 return !(flags & ~REF_NORMAL);
51}
52
Daniel Barkalow45773702007-10-30 01:05:40[diff] [blame]53int check_ref_type(const struct ref *ref, int flags)
54{
René Scharfebe0b3f82014-08-30 09:46:54[diff] [blame]55 return check_ref(ref->name, flags);
Daniel Barkalow45773702007-10-30 01:05:40[diff] [blame]56}
57
Nguyễn Thái Ngọc Duyd2bff222018-04-14 19:19:43[diff] [blame]58static NORETURN void die_initial_contact(int unexpected)
Heiko Voigt46284dd2012-06-19 18:24:50[diff] [blame]59{
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]60 /*
61 * A hang-up after seeing some response from the other end
62 * means that it is unexpected, as we know the other end is
63 * willing to talk to us. A hang-up before seeing any
64 * response does not necessarily mean an ACL problem, though.
65 */
Jonathan Nieder55e4f932016-09-09 17:36:29[diff] [blame]66 if (unexpected)
Nguyễn Thái Ngọc Duy1a07e592018-07-21 07:49:19[diff] [blame]67 die(_("the remote end hung up upon initial contact"));
Heiko Voigt46284dd2012-06-19 18:24:50[diff] [blame]68 else
Vasco Almeidaf2b93b32016-09-19 13:08:17[diff] [blame]69 die(_("Could not read from remote repository.\n\n"
70 "Please make sure you have the correct access rights\n"
71 "and the repository exists."));
Heiko Voigt46284dd2012-06-19 18:24:50[diff] [blame]72}
73
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]74/* Checks if the server supports the capability 'c' */
Jeff Kinga31cfe32022-12-13 10:52:58[diff] [blame]75int server_supports_v2(const char *c)
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]76{
77 int i;
78
Jeff Kingd70a9eb2020-07-29 00:37:20[diff] [blame]79 for (i = 0; i < server_capabilities_v2.nr; i++) {
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]80 const char *out;
Jeff Kingd70a9eb2020-07-29 00:37:20[diff] [blame]81 if (skip_prefix(server_capabilities_v2.v[i], c, &out) &&
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]82 (!*out || *out == '='))
83 return 1;
84 }
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]85 return 0;
86}
87
Jeff Kinga31cfe32022-12-13 10:52:58[diff] [blame]88void ensure_server_supports_v2(const char *c)
89{
90 if (!server_supports_v2(c))
91 die(_("server doesn't support '%s'"), c);
92}
93
brian m. carlson1349ffe2020-05-25 19:58:53[diff] [blame]94int server_feature_v2(const char *c, const char **v)
95{
96 int i;
97
Jeff Kingd70a9eb2020-07-29 00:37:20[diff] [blame]98 for (i = 0; i < server_capabilities_v2.nr; i++) {
brian m. carlson1349ffe2020-05-25 19:58:53[diff] [blame]99 const char *out;
Jeff Kingd70a9eb2020-07-29 00:37:20[diff] [blame]100 if (skip_prefix(server_capabilities_v2.v[i], c, &out) &&
brian m. carlson1349ffe2020-05-25 19:58:53[diff] [blame]101 (*out == '=')) {
102 *v = out + 1;
103 return 1;
104 }
105 }
106 return 0;
107}
108
Brandon Williamsf7e20502018-03-15 17:31:29[diff] [blame]109int server_supports_feature(const char *c, const char *feature,
110 int die_on_error)
111{
112 int i;
113
Jeff Kingd70a9eb2020-07-29 00:37:20[diff] [blame]114 for (i = 0; i < server_capabilities_v2.nr; i++) {
Brandon Williamsf7e20502018-03-15 17:31:29[diff] [blame]115 const char *out;
Jeff Kingd70a9eb2020-07-29 00:37:20[diff] [blame]116 if (skip_prefix(server_capabilities_v2.v[i], c, &out) &&
Brandon Williamsf7e20502018-03-15 17:31:29[diff] [blame]117 (!*out || *(out++) == '=')) {
118 if (parse_feature_request(out, feature))
119 return 1;
120 else
121 break;
122 }
123 }
124
125 if (die_on_error)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]126 die(_("server doesn't support feature '%s'"), feature);
Brandon Williamsf7e20502018-03-15 17:31:29[diff] [blame]127
128 return 0;
129}
130
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]131static void process_capabilities_v2(struct packet_reader *reader)
132{
133 while (packet_reader_read(reader) == PACKET_READ_NORMAL)
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]134 strvec_push(&server_capabilities_v2, reader->line);
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]135
136 if (reader->status != PACKET_READ_FLUSH)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]137 die(_("expected flush after capabilities"));
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]138}
139
Brandon Williamsad6ac122018-03-14 18:31:45[diff] [blame]140enum protocol_version discover_version(struct packet_reader *reader)
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]141{
142 enum protocol_version version = protocol_unknown_version;
143
144 /*
145 * Peek the first line of the server's response to
146 * determine the protocol version the server is speaking.
147 */
148 switch (packet_reader_peek(reader)) {
149 case PACKET_READ_EOF:
150 die_initial_contact(0);
151 case PACKET_READ_FLUSH:
152 case PACKET_READ_DELIM:
Denton Liu0181b602020-05-19 10:53:59[diff] [blame]153 case PACKET_READ_RESPONSE_END:
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]154 version = protocol_v0;
155 break;
156 case PACKET_READ_NORMAL:
157 version = determine_protocol_version_client(reader->line);
158 break;
159 }
160
161 switch (version) {
Brandon Williams8f6982b2018-03-14 18:31:47[diff] [blame]162 case protocol_v2:
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]163 process_capabilities_v2(reader);
Brandon Williams8f6982b2018-03-14 18:31:47[diff] [blame]164 break;
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]165 case protocol_v1:
166 /* Read the peeked version line */
167 packet_reader_read(reader);
168 break;
169 case protocol_v0:
170 break;
171 case protocol_unknown_version:
172 BUG("unknown protocol version");
173 }
174
Josh Steadmon626beeb2021-08-10 17:20:39[diff] [blame]175 trace2_data_intmax("transfer", NULL, "negotiated-version", version);
176
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]177 return version;
178}
179
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]180static void parse_one_symref_info(struct string_list *symref, const char *val, int len)
181{
182 char *sym, *target;
183 struct string_list_item *item;
184
185 if (!len)
186 return; /* just "symref" */
187 /* e.g. "symref=HEAD:refs/heads/master" */
René Scharfe5c0b13f2014-07-19 15:35:34[diff] [blame]188 sym = xmemdupz(val, len);
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]189 target = strchr(sym, ':');
190 if (!target)
191 /* just "symref=something" */
192 goto reject;
193 *(target++) = '\0';
194 if (check_refname_format(sym, REFNAME_ALLOW_ONELEVEL) ||
195 check_refname_format(target, REFNAME_ALLOW_ONELEVEL))
196 /* "symref=bogus:pair */
197 goto reject;
Jeff Kingef4fe562017-05-25 19:33:05[diff] [blame]198 item = string_list_append_nodup(symref, sym);
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]199 item->util = target;
200 return;
201reject:
202 free(sym);
203 return;
204}
205
206static void annotate_refs_with_symref_info(struct ref *ref)
207{
208 struct string_list symref = STRING_LIST_INIT_DUP;
Jeff King7ce4c8f2023-04-14 21:25:20[diff] [blame]209 size_t offset = 0;
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]210
brian m. carlson2c6a403d2020-05-25 19:58:52[diff] [blame]211 while (1) {
Jeff King7ce4c8f2023-04-14 21:25:20[diff] [blame]212 size_t len;
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]213 const char *val;
214
brian m. carlson2c6a403d2020-05-25 19:58:52[diff] [blame]215 val = next_server_feature_value("symref", &len, &offset);
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]216 if (!val)
217 break;
218 parse_one_symref_info(&symref, val, len);
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]219 }
Michael Haggerty3383e192014-11-25 08:02:35[diff] [blame]220 string_list_sort(&symref);
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]221
222 for (; ref; ref = ref->next) {
223 struct string_list_item *item;
224 item = string_list_lookup(&symref, ref->name);
225 if (!item)
226 continue;
227 ref->symref = xstrdup((char *)item->util);
228 }
229 string_list_clear(&symref, 0);
230}
231
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]232static void process_capabilities(struct packet_reader *reader, int *linelen)
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]233{
brian m. carlson7c601dc2020-05-25 19:59:00[diff] [blame]234 const char *feat_val;
Jeff King7ce4c8f2023-04-14 21:25:20[diff] [blame]235 size_t feat_len;
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]236 const char *line = reader->line;
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]237 int nul_location = strlen(line);
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]238 if (nul_location == *linelen)
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]239 return;
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]240 server_capabilities_v1 = xstrdup(line + nul_location + 1);
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]241 *linelen = nul_location;
brian m. carlson7c601dc2020-05-25 19:59:00[diff] [blame]242
243 feat_val = server_feature_value("object-format", &feat_len);
244 if (feat_val) {
245 char *hash_name = xstrndup(feat_val, feat_len);
246 int hash_algo = hash_algo_by_name(hash_name);
247 if (hash_algo != GIT_HASH_UNKNOWN)
248 reader->hash_algo = &hash_algos[hash_algo];
249 free(hash_name);
250 } else {
251 reader->hash_algo = &hash_algos[GIT_HASH_SHA1];
252 }
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]253}
254
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]255static int process_dummy_ref(const struct packet_reader *reader)
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]256{
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]257 const char *line = reader->line;
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]258 struct object_id oid;
259 const char *name;
260
brian m. carlson7c601dc2020-05-25 19:59:00[diff] [blame]261 if (parse_oid_hex_algop(line, &oid, &name, reader->hash_algo))
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]262 return 0;
263 if (*name != ' ')
264 return 0;
265 name++;
266
Jeff King13e67aa2023-04-14 21:25:11[diff] [blame]267 return oideq(reader->hash_algo->null_oid, &oid) &&
268 !strcmp(name, "capabilities^{}");
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]269}
270
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]271static void check_no_capabilities(const char *line, int len)
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]272{
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]273 if (strlen(line) != len)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]274 warning(_("ignoring capabilities after first line '%s'"),
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]275 line + strlen(line));
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]276}
277
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]278static int process_ref(const struct packet_reader *reader, int len,
279 struct ref ***list, unsigned int flags,
280 struct oid_array *extra_have)
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]281{
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]282 const char *line = reader->line;
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]283 struct object_id old_oid;
284 const char *name;
285
brian m. carlson7c601dc2020-05-25 19:59:00[diff] [blame]286 if (parse_oid_hex_algop(line, &old_oid, &name, reader->hash_algo))
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]287 return 0;
288 if (*name != ' ')
289 return 0;
290 name++;
291
292 if (extra_have && !strcmp(name, ".have")) {
293 oid_array_append(extra_have, &old_oid);
294 } else if (!strcmp(name, "capabilities^{}")) {
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]295 die(_("protocol error: unexpected capabilities^{}"));
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]296 } else if (check_ref(name, flags)) {
297 struct ref *ref = alloc_ref(name);
298 oidcpy(&ref->old_oid, &old_oid);
299 **list = ref;
300 *list = &ref->next;
301 }
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]302 check_no_capabilities(line, len);
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]303 return 1;
304}
305
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]306static int process_shallow(const struct packet_reader *reader, int len,
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]307 struct oid_array *shallow_points)
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]308{
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]309 const char *line = reader->line;
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]310 const char *arg;
311 struct object_id old_oid;
312
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]313 if (!skip_prefix(line, "shallow ", &arg))
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]314 return 0;
315
brian m. carlson7c601dc2020-05-25 19:59:00[diff] [blame]316 if (get_oid_hex_algop(arg, &old_oid, reader->hash_algo))
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]317 die(_("protocol error: expected shallow sha-1, got '%s'"), arg);
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]318 if (!shallow_points)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]319 die(_("repository on the other end cannot be shallow"));
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]320 oid_array_append(shallow_points, &old_oid);
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]321 check_no_capabilities(line, len);
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]322 return 1;
323}
324
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]325enum get_remote_heads_state {
326 EXPECTING_FIRST_REF = 0,
327 EXPECTING_REF,
328 EXPECTING_SHALLOW,
329 EXPECTING_DONE,
330};
331
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]332/*
Linus Torvaldsd1c133f2005-07-16 20:55:50[diff] [blame]333 * Read all the refs from the other end
334 */
Brandon Williamsad6ac122018-03-14 18:31:45[diff] [blame]335struct ref **get_remote_heads(struct packet_reader *reader,
Jeff King85edf4f2013-02-20 20:06:45[diff] [blame]336 struct ref **list, unsigned int flags,
brian m. carlson910650d2017-03-31 01:40:00[diff] [blame]337 struct oid_array *extra_have,
338 struct oid_array *shallow_points)
Linus Torvaldsd1c133f2005-07-16 20:55:50[diff] [blame]339{
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]340 struct ref **orig_list = list;
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]341 int len = 0;
342 enum get_remote_heads_state state = EXPECTING_FIRST_REF;
Jonathan Nieder55e4f932016-09-09 17:36:29[diff] [blame]343
Linus Torvaldsd1c133f2005-07-16 20:55:50[diff] [blame]344 *list = NULL;
Linus Torvaldsd1c133f2005-07-16 20:55:50[diff] [blame]345
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]346 while (state != EXPECTING_DONE) {
Brandon Williamsad6ac122018-03-14 18:31:45[diff] [blame]347 switch (packet_reader_read(reader)) {
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]348 case PACKET_READ_EOF:
349 die_initial_contact(1);
350 case PACKET_READ_NORMAL:
Brandon Williamsad6ac122018-03-14 18:31:45[diff] [blame]351 len = reader->pktlen;
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]352 break;
353 case PACKET_READ_FLUSH:
354 state = EXPECTING_DONE;
355 break;
356 case PACKET_READ_DELIM:
Denton Liu0181b602020-05-19 10:53:59[diff] [blame]357 case PACKET_READ_RESPONSE_END:
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]358 die(_("invalid packet"));
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]359 }
360
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]361 switch (state) {
362 case EXPECTING_FIRST_REF:
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]363 process_capabilities(reader, &len);
364 if (process_dummy_ref(reader)) {
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]365 state = EXPECTING_SHALLOW;
366 break;
367 }
368 state = EXPECTING_REF;
369 /* fallthrough */
370 case EXPECTING_REF:
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]371 if (process_ref(reader, len, &list, flags, extra_have))
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]372 break;
373 state = EXPECTING_SHALLOW;
374 /* fallthrough */
375 case EXPECTING_SHALLOW:
brian m. carlson92315e52020-05-25 19:58:49[diff] [blame]376 if (process_shallow(reader, len, shallow_points))
Jonathan Tan0cd83282017-09-26 23:56:19[diff] [blame]377 break;
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]378 die(_("protocol error: unexpected '%s'"), reader->line);
Brandon Williams7e3e4792018-03-14 18:31:44[diff] [blame]379 case EXPECTING_DONE:
380 break;
Nguyễn Thái Ngọc Duyb06dcd72013-12-05 13:02:33[diff] [blame]381 }
Linus Torvaldsd1c133f2005-07-16 20:55:50[diff] [blame]382 }
Junio C Hamanoa45b5f02013-09-18 02:10:31[diff] [blame]383
384 annotate_refs_with_symref_info(*orig_list);
385
Linus Torvaldsd1c133f2005-07-16 20:55:50[diff] [blame]386 return list;
387}
388
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]389/* Returns 1 when a valid ref has been added to `list`, 0 otherwise */
Jonathan Tan4f37d452021-02-05 20:48:49[diff] [blame]390static int process_ref_v2(struct packet_reader *reader, struct ref ***list,
Ævar Arnfjörð Bjarmasonf36d4f82022-02-05 00:08:14[diff] [blame]391 const char **unborn_head_target)
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]392{
393 int ret = 1;
394 int i = 0;
395 struct object_id old_oid;
396 struct ref *ref;
397 struct string_list line_sections = STRING_LIST_INIT_DUP;
398 const char *end;
brian m. carlson67e9a702020-05-25 19:59:15[diff] [blame]399 const char *line = reader->line;
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]400
401 /*
402 * Ref lines have a number of fields which are space deliminated. The
403 * first field is the OID of the ref. The second field is the ref
404 * name. Subsequent fields (symref-target and peeled) are optional and
405 * don't have a particular order.
406 */
407 if (string_list_split(&line_sections, line, ' ', -1) < 2) {
408 ret = 0;
409 goto out;
410 }
411
Jonathan Tan4f37d452021-02-05 20:48:49[diff] [blame]412 if (!strcmp("unborn", line_sections.items[i].string)) {
413 i++;
414 if (unborn_head_target &&
415 !strcmp("HEAD", line_sections.items[i++].string)) {
416 /*
417 * Look for the symref target (if any). If found,
418 * return it to the caller.
419 */
420 for (; i < line_sections.nr; i++) {
421 const char *arg = line_sections.items[i].string;
422
423 if (skip_prefix(arg, "symref-target:", &arg)) {
424 *unborn_head_target = xstrdup(arg);
425 break;
426 }
427 }
428 }
429 goto out;
430 }
brian m. carlsonab672352020-05-25 19:59:16[diff] [blame]431 if (parse_oid_hex_algop(line_sections.items[i++].string, &old_oid, &end, reader->hash_algo) ||
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]432 *end) {
433 ret = 0;
434 goto out;
435 }
436
437 ref = alloc_ref(line_sections.items[i++].string);
438
brian m. carlsonab672352020-05-25 19:59:16[diff] [blame]439 memcpy(ref->old_oid.hash, old_oid.hash, reader->hash_algo->rawsz);
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]440 **list = ref;
441 *list = &ref->next;
442
443 for (; i < line_sections.nr; i++) {
444 const char *arg = line_sections.items[i].string;
445 if (skip_prefix(arg, "symref-target:", &arg))
446 ref->symref = xstrdup(arg);
447
448 if (skip_prefix(arg, "peeled:", &arg)) {
449 struct object_id peeled_oid;
450 char *peeled_name;
451 struct ref *peeled;
brian m. carlsonab672352020-05-25 19:59:16[diff] [blame]452 if (parse_oid_hex_algop(arg, &peeled_oid, &end,
453 reader->hash_algo) || *end) {
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]454 ret = 0;
455 goto out;
456 }
457
458 peeled_name = xstrfmt("%s^{}", ref->name);
459 peeled = alloc_ref(peeled_name);
460
brian m. carlsonab672352020-05-25 19:59:16[diff] [blame]461 memcpy(peeled->old_oid.hash, peeled_oid.hash,
462 reader->hash_algo->rawsz);
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]463 **list = peeled;
464 *list = &peeled->next;
465
466 free(peeled_name);
467 }
468 }
469
470out:
471 string_list_clear(&line_sections, 0);
472 return ret;
473}
474
Denton Liub0df0c12020-05-19 10:54:00[diff] [blame]475void check_stateless_delimiter(int stateless_rpc,
476 struct packet_reader *reader,
477 const char *error)
478{
479 if (!stateless_rpc)
480 return; /* not in stateless mode, no delimiter expected */
481 if (packet_reader_read(reader) != PACKET_READ_RESPONSE_END)
482 die("%s", error);
483}
484
Ævar Arnfjörð Bjarmason86f4e312022-05-16 20:10:58[diff] [blame]485static void send_capabilities(int fd_out, struct packet_reader *reader)
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]486{
brian m. carlsonab672352020-05-25 19:59:16[diff] [blame]487 const char *hash_name;
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]488
Jeff Kinga31cfe32022-12-13 10:52:58[diff] [blame]489 if (server_supports_v2("agent"))
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]490 packet_write_fmt(fd_out, "agent=%s", git_user_agent_sanitized());
491
brian m. carlsonab672352020-05-25 19:59:16[diff] [blame]492 if (server_feature_v2("object-format", &hash_name)) {
493 int hash_algo = hash_algo_by_name(hash_name);
494 if (hash_algo == GIT_HASH_UNKNOWN)
495 die(_("unknown object format '%s' specified by server"), hash_name);
496 reader->hash_algo = &hash_algos[hash_algo];
497 packet_write_fmt(fd_out, "object-format=%s", reader->hash_algo->name);
brian m. carlson9de0dd32020-05-25 19:59:17[diff] [blame]498 } else {
499 reader->hash_algo = &hash_algos[GIT_HASH_SHA1];
brian m. carlsonab672352020-05-25 19:59:16[diff] [blame]500 }
Ævar Arnfjörð Bjarmason86f4e312022-05-16 20:10:58[diff] [blame]501}
502
Ævar Arnfjörð Bjarmason0cfde742022-12-22 15:14:09[diff] [blame]503int get_remote_bundle_uri(int fd_out, struct packet_reader *reader,
504 struct bundle_list *bundles, int stateless_rpc)
505{
506 int line_nr = 1;
507
508 /* Assert bundle-uri support */
Junio C Hamano0903d8b2023-01-02 12:37:18[diff] [blame]509 ensure_server_supports_v2("bundle-uri");
Ævar Arnfjörð Bjarmason0cfde742022-12-22 15:14:09[diff] [blame]510
511 /* (Re-)send capabilities */
512 send_capabilities(fd_out, reader);
513
514 /* Send command */
515 packet_write_fmt(fd_out, "command=bundle-uri\n");
516 packet_delim(fd_out);
517
518 packet_flush(fd_out);
519
520 /* Process response from server */
521 while (packet_reader_read(reader) == PACKET_READ_NORMAL) {
522 const char *line = reader->line;
523 line_nr++;
524
525 if (!bundle_uri_parse_line(bundles, line))
526 continue;
527
528 return error(_("error on bundle-uri response line %d: %s"),
529 line_nr, line);
530 }
531
532 if (reader->status != PACKET_READ_FLUSH)
533 return error(_("expected flush after bundle-uri listing"));
534
535 /*
536 * Might die(), but obscure enough that that's OK, e.g. in
537 * serve.c we'll call BUG() on its equivalent (the
538 * PACKET_READ_RESPONSE_END check).
539 */
540 check_stateless_delimiter(stateless_rpc, reader,
541 _("expected response end packet after ref listing"));
542
543 return 0;
544}
545
Ævar Arnfjörð Bjarmason86f4e312022-05-16 20:10:58[diff] [blame]546struct ref **get_remote_refs(int fd_out, struct packet_reader *reader,
547 struct ref **list, int for_push,
548 struct transport_ls_refs_options *transport_options,
549 const struct string_list *server_options,
550 int stateless_rpc)
551{
552 int i;
553 struct strvec *ref_prefixes = transport_options ?
554 &transport_options->ref_prefixes : NULL;
555 const char **unborn_head_target = transport_options ?
556 &transport_options->unborn_head_target : NULL;
557 *list = NULL;
558
Jeff Kinga31cfe32022-12-13 10:52:58[diff] [blame]559 ensure_server_supports_v2("ls-refs");
560 packet_write_fmt(fd_out, "command=ls-refs\n");
Ævar Arnfjörð Bjarmason86f4e312022-05-16 20:10:58[diff] [blame]561
562 /* Send capabilities */
563 send_capabilities(fd_out, reader);
brian m. carlsonab672352020-05-25 19:59:16[diff] [blame]564
Jeff Kinga31cfe32022-12-13 10:52:58[diff] [blame]565 if (server_options && server_options->nr) {
566 ensure_server_supports_v2("server-option");
Brandon Williamsff473222018-04-23 22:46:23[diff] [blame]567 for (i = 0; i < server_options->nr; i++)
568 packet_write_fmt(fd_out, "server-option=%s",
569 server_options->items[i].string);
Jeff Kinga31cfe32022-12-13 10:52:58[diff] [blame]570 }
Brandon Williamsff473222018-04-23 22:46:23[diff] [blame]571
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]572 packet_delim(fd_out);
573 /* When pushing we don't want to request the peeled tags */
574 if (!for_push)
575 packet_write_fmt(fd_out, "peel\n");
576 packet_write_fmt(fd_out, "symrefs\n");
Jonathan Tan4f37d452021-02-05 20:48:49[diff] [blame]577 if (server_supports_feature("ls-refs", "unborn", 0))
578 packet_write_fmt(fd_out, "unborn\n");
Jeff Kingd70a9eb2020-07-29 00:37:20[diff] [blame]579 for (i = 0; ref_prefixes && i < ref_prefixes->nr; i++) {
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]580 packet_write_fmt(fd_out, "ref-prefix %s\n",
Jeff Kingd70a9eb2020-07-29 00:37:20[diff] [blame]581 ref_prefixes->v[i]);
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]582 }
583 packet_flush(fd_out);
584
585 /* Process response from server */
586 while (packet_reader_read(reader) == PACKET_READ_NORMAL) {
Jonathan Tan4f37d452021-02-05 20:48:49[diff] [blame]587 if (!process_ref_v2(reader, &list, unborn_head_target))
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]588 die(_("invalid ls-refs response: %s"), reader->line);
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]589 }
590
591 if (reader->status != PACKET_READ_FLUSH)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]592 die(_("expected flush after ref listing"));
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]593
Denton Liub0df0c12020-05-19 10:54:00[diff] [blame]594 check_stateless_delimiter(stateless_rpc, reader,
595 _("expected response end packet after ref listing"));
596
Brandon Williamse52449b2018-03-15 17:31:21[diff] [blame]597 return list;
598}
599
Jeff King7ce4c8f2023-04-14 21:25:20[diff] [blame]600const char *parse_feature_value(const char *feature_list, const char *feature, size_t *lenp, size_t *offset)
Junio C Hamanof47182c2012-01-08 21:06:19[diff] [blame]601{
Jeff Kingaa962fe2023-04-14 21:24:16[diff] [blame]602 const char *orig_start = feature_list;
Jeff King7ce4c8f2023-04-14 21:25:20[diff] [blame]603 size_t len;
Junio C Hamanof47182c2012-01-08 21:06:19[diff] [blame]604
605 if (!feature_list)
606 return NULL;
607
608 len = strlen(feature);
brian m. carlson2c6a403d2020-05-25 19:58:52[diff] [blame]609 if (offset)
610 feature_list += *offset;
Junio C Hamanof47182c2012-01-08 21:06:19[diff] [blame]611 while (*feature_list) {
612 const char *found = strstr(feature_list, feature);
613 if (!found)
614 return NULL;
Jeff King94427102012-08-14 01:59:27[diff] [blame]615 if (feature_list == found || isspace(found[-1])) {
616 const char *value = found + len;
617 /* feature with no value (e.g., "thin-pack") */
618 if (!*value || isspace(*value)) {
619 if (lenp)
620 *lenp = 0;
Andrzej Hunt44d2aec2021-09-26 15:58:33[diff] [blame]621 if (offset)
Jeff Kingaa962fe2023-04-14 21:24:16[diff] [blame]622 *offset = found + len - orig_start;
Jeff King94427102012-08-14 01:59:27[diff] [blame]623 return value;
624 }
625 /* feature with a value (e.g., "agent=git/1.2.3") */
626 else if (*value == '=') {
Jeff King7ce4c8f2023-04-14 21:25:20[diff] [blame]627 size_t end;
brian m. carlson2c6a403d2020-05-25 19:58:52[diff] [blame]628
Jeff King94427102012-08-14 01:59:27[diff] [blame]629 value++;
brian m. carlson2c6a403d2020-05-25 19:58:52[diff] [blame]630 end = strcspn(value, " \t\n");
Jeff King94427102012-08-14 01:59:27[diff] [blame]631 if (lenp)
brian m. carlson2c6a403d2020-05-25 19:58:52[diff] [blame]632 *lenp = end;
633 if (offset)
Jeff Kingaa962fe2023-04-14 21:24:16[diff] [blame]634 *offset = value + end - orig_start;
Jeff King94427102012-08-14 01:59:27[diff] [blame]635 return value;
636 }
637 /*
638 * otherwise we matched a substring of another feature;
639 * keep looking
640 */
641 }
Junio C Hamanof47182c2012-01-08 21:06:19[diff] [blame]642 feature_list = found + 1;
643 }
644 return NULL;
Johannes Schindelin211b5f92005-10-28 02:48:54[diff] [blame]645}
646
brian m. carlson122037c2020-05-25 19:58:56[diff] [blame]647int server_supports_hash(const char *desired, int *feature_supported)
648{
Jeff King7ce4c8f2023-04-14 21:25:20[diff] [blame]649 size_t offset = 0;
650 size_t len;
brian m. carlson122037c2020-05-25 19:58:56[diff] [blame]651 const char *hash;
652
653 hash = next_server_feature_value("object-format", &len, &offset);
654 if (feature_supported)
655 *feature_supported = !!hash;
656 if (!hash) {
657 hash = hash_algos[GIT_HASH_SHA1].name;
658 len = strlen(hash);
659 }
660 while (hash) {
661 if (!xstrncmpz(desired, hash, len))
662 return 1;
663
664 hash = next_server_feature_value("object-format", &len, &offset);
665 }
666 return 0;
667}
668
Jeff King94427102012-08-14 01:59:27[diff] [blame]669int parse_feature_request(const char *feature_list, const char *feature)
670{
brian m. carlson2c6a403d2020-05-25 19:58:52[diff] [blame]671 return !!parse_feature_value(feature_list, feature, NULL, NULL);
672}
673
Jeff King7ce4c8f2023-04-14 21:25:20[diff] [blame]674static const char *next_server_feature_value(const char *feature, size_t *len, size_t *offset)
brian m. carlson2c6a403d2020-05-25 19:58:52[diff] [blame]675{
676 return parse_feature_value(server_capabilities_v1, feature, len, offset);
Jeff King94427102012-08-14 01:59:27[diff] [blame]677}
678
Jeff King7ce4c8f2023-04-14 21:25:20[diff] [blame]679const char *server_feature_value(const char *feature, size_t *len)
Jeff King94427102012-08-14 01:59:27[diff] [blame]680{
brian m. carlson2c6a403d2020-05-25 19:58:52[diff] [blame]681 return parse_feature_value(server_capabilities_v1, feature, len, NULL);
Jeff King94427102012-08-14 01:59:27[diff] [blame]682}
683
684int server_supports(const char *feature)
685{
686 return !!server_feature_value(feature, NULL);
687}
688
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]689enum protocol {
690 PROTO_LOCAL = 1,
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]691 PROTO_FILE,
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]692 PROTO_SSH,
Gary V. Vaughan4b055482010-05-14 09:31:35[diff] [blame]693 PROTO_GIT
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]694};
695
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]696int url_is_local_not_ssh(const char *url)
697{
698 const char *colon = strchr(url, ':');
699 const char *slash = strchr(url, '/');
700 return !colon || (slash && slash < colon) ||
Johannes Schindelinf82a97e2019-09-05 22:09:10[diff] [blame]701 (has_dos_drive_prefix(url) && is_valid_path(url));
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]702}
703
Torsten Bögershausen5610b7c2013-11-28 19:49:17[diff] [blame]704static const char *prot_name(enum protocol protocol)
705{
706 switch (protocol) {
707 case PROTO_LOCAL:
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]708 case PROTO_FILE:
Torsten Bögershausen5610b7c2013-11-28 19:49:17[diff] [blame]709 return "file";
710 case PROTO_SSH:
711 return "ssh";
712 case PROTO_GIT:
713 return "git";
714 default:
Tobias Klauser83e6bda2015-09-24 12:44:49[diff] [blame]715 return "unknown protocol";
Torsten Bögershausen5610b7c2013-11-28 19:49:17[diff] [blame]716 }
717}
718
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]719static enum protocol get_protocol(const char *name)
720{
721 if (!strcmp(name, "ssh"))
722 return PROTO_SSH;
723 if (!strcmp(name, "git"))
724 return PROTO_GIT;
Carlos Martín Nieto07c77822016-02-15 14:29:06[diff] [blame]725 if (!strcmp(name, "git+ssh")) /* deprecated - do not use */
Linus Torvaldsc05186c2005-10-15 00:14:56[diff] [blame]726 return PROTO_SSH;
Carlos Martín Nieto07c77822016-02-15 14:29:06[diff] [blame]727 if (!strcmp(name, "ssh+git")) /* deprecated - do not use */
Linus Torvaldsc05186c2005-10-15 00:14:56[diff] [blame]728 return PROTO_SSH;
Linus Torvalds72a4f4b2007-08-01 17:03:37[diff] [blame]729 if (!strcmp(name, "file"))
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]730 return PROTO_FILE;
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]731 die(_("protocol '%s' is not supported"), name);
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]732}
733
Torsten Bögershausen86ceb332015-02-21 15:52:48[diff] [blame]734static char *host_end(char **hoststart, int removebrackets)
735{
736 char *host = *hoststart;
737 char *end;
738 char *start = strstr(host, "@[");
739 if (start)
740 start++; /* Jump over '@' */
741 else
742 start = host;
743 if (start[0] == '[') {
744 end = strchr(start + 1, ']');
745 if (end) {
746 if (removebrackets) {
747 *end = 0;
748 memmove(start, start + 1, end - start);
749 end++;
750 }
751 } else
752 end = host;
753 } else
754 end = host;
755 return end;
756}
757
YOSHIFUJI Hideaki5ba88442005-07-21 13:10:36[diff] [blame]758#define STR_(s) # s
759#define STR(s) STR_(s)
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]760
Michael Lukashov72a534d2010-02-17 20:56:02[diff] [blame]761static void get_host_and_port(char **host, const char **port)
762{
763 char *colon, *end;
Torsten Bögershausen86ceb332015-02-21 15:52:48[diff] [blame]764 end = host_end(host, 1);
Michael Lukashov72a534d2010-02-17 20:56:02[diff] [blame]765 colon = strchr(end, ':');
Michael Lukashov72a534d2010-02-17 20:56:02[diff] [blame]766 if (colon) {
Torsten Bögershausen86ceb332015-02-21 15:52:48[diff] [blame]767 long portnr = strtol(colon + 1, &end, 10);
768 if (end != colon + 1 && *end == '\0' && 0 <= portnr && portnr < 65536) {
769 *colon = 0;
770 *port = colon + 1;
Torsten Bögershausen6b6c5f72015-04-07 20:03:25[diff] [blame]771 } else if (!colon[1]) {
772 *colon = 0;
Torsten Bögershausen86ceb332015-02-21 15:52:48[diff] [blame]773 }
Michael Lukashov72a534d2010-02-17 20:56:02[diff] [blame]774 }
775}
776
Eric Wonge47a8582011-12-06 04:39:36[diff] [blame]777static void enable_keepalive(int sockfd)
778{
779 int ka = 1;
780
781 if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &ka, sizeof(ka)) < 0)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]782 error_errno(_("unable to set SO_KEEPALIVE on socket"));
Eric Wonge47a8582011-12-06 04:39:36[diff] [blame]783}
784
hpa49744d62005-09-28 23:52:21[diff] [blame]785#ifndef NO_IPV6
hpa4c505f72005-09-28 23:37:58[diff] [blame]786
Alex Riesenba505322007-05-23 21:34:27[diff] [blame]787static const char *ai_name(const struct addrinfo *ai)
788{
Benjamin Kramer785a9852009-04-24 12:16:41[diff] [blame]789 static char addr[NI_MAXHOST];
790 if (getnameinfo(ai->ai_addr, ai->ai_addrlen, addr, sizeof(addr), NULL, 0,
791 NI_NUMERICHOST) != 0)
Jeff King5096d492015-09-24 21:06:08[diff] [blame]792 xsnprintf(addr, sizeof(addr), "(unknown)");
Benjamin Kramer785a9852009-04-24 12:16:41[diff] [blame]793
Alex Riesenba505322007-05-23 21:34:27[diff] [blame]794 return addr;
795}
796
Jon Loeliger5ad312b2006-06-07 03:58:41[diff] [blame]797/*
798 * Returns a connected socket() fd, or else die()s.
799 */
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]800static int git_tcp_connect_sock(char *host, int flags)
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]801{
Dave Zarzycki63a995b2011-07-12 16:28:34[diff] [blame]802 struct strbuf error_message = STRBUF_INIT;
803 int sockfd = -1;
Timo Hirvonen554fe202006-06-28 09:04:39[diff] [blame]804 const char *port = STR(DEFAULT_GIT_PORT);
YOSHIFUJI Hideaki5ba88442005-07-21 13:10:36[diff] [blame]805 struct addrinfo hints, *ai0, *ai;
806 int gai;
Alex Riesenba505322007-05-23 21:34:27[diff] [blame]807 int cnt = 0;
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]808
Michael Lukashov72a534d2010-02-17 20:56:02[diff] [blame]809 get_host_and_port(&host, &port);
810 if (!*port)
811 port = "<none>";
YOSHIFUJI Hideaki5ba88442005-07-21 13:10:36[diff] [blame]812
813 memset(&hints, 0, sizeof(hints));
Eric Wongc915f112016-02-03 04:09:14[diff] [blame]814 if (flags & CONNECT_IPV4)
815 hints.ai_family = AF_INET;
816 else if (flags & CONNECT_IPV6)
817 hints.ai_family = AF_INET6;
YOSHIFUJI Hideaki5ba88442005-07-21 13:10:36[diff] [blame]818 hints.ai_socktype = SOCK_STREAM;
819 hints.ai_protocol = IPPROTO_TCP;
820
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]821 if (flags & CONNECT_VERBOSE)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]822 fprintf(stderr, _("Looking up %s ... "), host);
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]823
YOSHIFUJI Hideaki5ba88442005-07-21 13:10:36[diff] [blame]824 gai = getaddrinfo(host, port, &hints, &ai);
825 if (gai)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]826 die(_("unable to look up %s (port %s) (%s)"), host, port, gai_strerror(gai));
YOSHIFUJI Hideaki5ba88442005-07-21 13:10:36[diff] [blame]827
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]828 if (flags & CONNECT_VERBOSE)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]829 /* TRANSLATORS: this is the end of "Looking up %s ... " */
830 fprintf(stderr, _("done.\nConnecting to %s (port %s) ... "), host, port);
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]831
Erik Faye-Lunde08afec2011-08-01 11:16:09[diff] [blame]832 for (ai0 = ai; ai; ai = ai->ai_next, cnt++) {
Jon Loeliger5ad312b2006-06-07 03:58:41[diff] [blame]833 sockfd = socket(ai->ai_family,
834 ai->ai_socktype, ai->ai_protocol);
Dave Zarzycki63a995b2011-07-12 16:28:34[diff] [blame]835 if ((sockfd < 0) ||
836 (connect(sockfd, ai->ai_addr, ai->ai_addrlen) < 0)) {
837 strbuf_addf(&error_message, "%s[%d: %s]: errno=%s\n",
838 host, cnt, ai_name(ai), strerror(errno));
839 if (0 <= sockfd)
840 close(sockfd);
YOSHIFUJI Hideaki5ba88442005-07-21 13:10:36[diff] [blame]841 sockfd = -1;
842 continue;
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]843 }
Alex Riesenba505322007-05-23 21:34:27[diff] [blame]844 if (flags & CONNECT_VERBOSE)
845 fprintf(stderr, "%s ", ai_name(ai));
YOSHIFUJI Hideaki5ba88442005-07-21 13:10:36[diff] [blame]846 break;
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]847 }
848
YOSHIFUJI Hideaki5ba88442005-07-21 13:10:36[diff] [blame]849 freeaddrinfo(ai0);
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]850
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]851 if (sockfd < 0)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]852 die(_("unable to connect to %s:\n%s"), host, error_message.buf);
YOSHIFUJI Hideaki5ba88442005-07-21 13:10:36[diff] [blame]853
Eric Wonge47a8582011-12-06 04:39:36[diff] [blame]854 enable_keepalive(sockfd);
855
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]856 if (flags & CONNECT_VERBOSE)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]857 /* TRANSLATORS: this is the end of "Connecting to %s (port %s) ... " */
858 fprintf_ln(stderr, _("done."));
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]859
Dave Zarzycki63a995b2011-07-12 16:28:34[diff] [blame]860 strbuf_release(&error_message);
861
Jon Loeliger5ad312b2006-06-07 03:58:41[diff] [blame]862 return sockfd;
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]863}
864
hpa49744d62005-09-28 23:52:21[diff] [blame]865#else /* NO_IPV6 */
hpa4c505f72005-09-28 23:37:58[diff] [blame]866
Jon Loeliger5ad312b2006-06-07 03:58:41[diff] [blame]867/*
868 * Returns a connected socket() fd, or else die()s.
869 */
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]870static int git_tcp_connect_sock(char *host, int flags)
hpa4c505f72005-09-28 23:37:58[diff] [blame]871{
Erik Faye-Lund7203a2d2011-08-01 11:16:10[diff] [blame]872 struct strbuf error_message = STRBUF_INIT;
873 int sockfd = -1;
Michael Lukashov72a534d2010-02-17 20:56:02[diff] [blame]874 const char *port = STR(DEFAULT_GIT_PORT);
875 char *ep;
hpa4c505f72005-09-28 23:37:58[diff] [blame]876 struct hostent *he;
877 struct sockaddr_in sa;
878 char **ap;
879 unsigned int nport;
Alex Riesenba505322007-05-23 21:34:27[diff] [blame]880 int cnt;
hpa4c505f72005-09-28 23:37:58[diff] [blame]881
Michael Lukashov72a534d2010-02-17 20:56:02[diff] [blame]882 get_host_and_port(&host, &port);
hpa4c505f72005-09-28 23:37:58[diff] [blame]883
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]884 if (flags & CONNECT_VERBOSE)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]885 fprintf(stderr, _("Looking up %s ... "), host);
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]886
hpa4c505f72005-09-28 23:37:58[diff] [blame]887 he = gethostbyname(host);
888 if (!he)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]889 die(_("unable to look up %s (%s)"), host, hstrerror(h_errno));
hpa4c505f72005-09-28 23:37:58[diff] [blame]890 nport = strtoul(port, &ep, 10);
891 if ( ep == port || *ep ) {
892 /* Not numeric */
893 struct servent *se = getservbyname(port,"tcp");
894 if ( !se )
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]895 die(_("unknown port %s"), port);
hpa4c505f72005-09-28 23:37:58[diff] [blame]896 nport = se->s_port;
897 }
898
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]899 if (flags & CONNECT_VERBOSE)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]900 /* TRANSLATORS: this is the end of "Looking up %s ... " */
901 fprintf(stderr, _("done.\nConnecting to %s (port %s) ... "), host, port);
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]902
Alex Riesenba505322007-05-23 21:34:27[diff] [blame]903 for (cnt = 0, ap = he->h_addr_list; *ap; ap++, cnt++) {
hpa4c505f72005-09-28 23:37:58[diff] [blame]904 memset(&sa, 0, sizeof sa);
905 sa.sin_family = he->h_addrtype;
Peter Anvin6573faf2005-09-29 00:26:44[diff] [blame]906 sa.sin_port = htons(nport);
Paul Sericec6164212005-11-22 13:54:23[diff] [blame]907 memcpy(&sa.sin_addr, *ap, he->h_length);
hpa4c505f72005-09-28 23:37:58[diff] [blame]908
Erik Faye-Lund7203a2d2011-08-01 11:16:10[diff] [blame]909 sockfd = socket(he->h_addrtype, SOCK_STREAM, 0);
910 if ((sockfd < 0) ||
911 connect(sockfd, (struct sockaddr *)&sa, sizeof sa) < 0) {
912 strbuf_addf(&error_message, "%s[%d: %s]: errno=%s\n",
Alex Riesenba505322007-05-23 21:34:27[diff] [blame]913 host,
914 cnt,
915 inet_ntoa(*(struct in_addr *)&sa.sin_addr),
Erik Faye-Lund7203a2d2011-08-01 11:16:10[diff] [blame]916 strerror(errno));
917 if (0 <= sockfd)
918 close(sockfd);
hpa4c505f72005-09-28 23:37:58[diff] [blame]919 sockfd = -1;
920 continue;
921 }
Alex Riesenba505322007-05-23 21:34:27[diff] [blame]922 if (flags & CONNECT_VERBOSE)
923 fprintf(stderr, "%s ",
924 inet_ntoa(*(struct in_addr *)&sa.sin_addr));
hpa4c505f72005-09-28 23:37:58[diff] [blame]925 break;
926 }
927
928 if (sockfd < 0)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]929 die(_("unable to connect to %s:\n%s"), host, error_message.buf);
hpa4c505f72005-09-28 23:37:58[diff] [blame]930
Eric Wonge47a8582011-12-06 04:39:36[diff] [blame]931 enable_keepalive(sockfd);
932
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]933 if (flags & CONNECT_VERBOSE)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]934 /* TRANSLATORS: this is the end of "Connecting to %s (port %s) ... " */
935 fprintf_ln(stderr, _("done."));
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]936
Jon Loeliger5ad312b2006-06-07 03:58:41[diff] [blame]937 return sockfd;
hpa4c505f72005-09-28 23:37:58[diff] [blame]938}
939
hpa49744d62005-09-28 23:52:21[diff] [blame]940#endif /* NO_IPV6 */
hpa4c505f72005-09-28 23:37:58[diff] [blame]941
Jon Loeliger5ad312b2006-06-07 03:58:41[diff] [blame]942
Jonathan Nieder8e349782017-11-20 21:22:54[diff] [blame]943/*
944 * Dummy child_process returned by git_connect() if the transport protocol
945 * does not need fork(2).
946 */
947static struct child_process no_fork = CHILD_PROCESS_INIT;
948
949int git_connection_is_socket(struct child_process *conn)
950{
951 return conn == &no_fork;
952}
953
954static struct child_process *git_tcp_connect(int fd[2], char *host, int flags)
Jon Loeliger5ad312b2006-06-07 03:58:41[diff] [blame]955{
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]956 int sockfd = git_tcp_connect_sock(host, flags);
Jon Loeliger5ad312b2006-06-07 03:58:41[diff] [blame]957
958 fd[0] = sockfd;
Junio C Hamanoec587fd2007-01-22 01:10:51[diff] [blame]959 fd[1] = dup(sockfd);
Jonathan Nieder8e349782017-11-20 21:22:54[diff] [blame]960
961 return &no_fork;
Jon Loeliger5ad312b2006-06-07 03:58:41[diff] [blame]962}
963
964
David Rientjes96f1e582006-08-15 17:23:48[diff] [blame]965static char *git_proxy_command;
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]966
Johannes Schindelinef90d6d2008-05-14 17:46:53[diff] [blame]967static int git_proxy_command_options(const char *var, const char *value,
Glen Chooa4e7e312023-06-28 19:26:22[diff] [blame]968 const struct config_context *ctx, void *cb)
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]969{
Junio C Hamanoe814bc42005-11-19 11:48:56[diff] [blame]970 if (!strcmp(var, "core.gitproxy")) {
YOSHIFUJI Hideaki / 吉藤英明c3df8562005-11-22 03:18:23[diff] [blame]971 const char *for_pos;
972 int matchlen = -1;
973 int hostlen;
Erik Faye-Lund15112c92009-03-11 02:38:12[diff] [blame]974 const char *rhost_name = cb;
975 int rhost_len = strlen(rhost_name);
YOSHIFUJI Hideaki / 吉藤英明c3df8562005-11-22 03:18:23[diff] [blame]976
Junio C Hamanoe814bc42005-11-19 11:48:56[diff] [blame]977 if (git_proxy_command)
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]978 return 0;
Junio C Hamanoc64b9ad2008-02-11 18:52:15[diff] [blame]979 if (!value)
980 return config_error_nonbool(var);
Junio C Hamanoe814bc42005-11-19 11:48:56[diff] [blame]981 /* [core]
982 * ;# matches www.kernel.org as well
983 * gitproxy = netcatter-1 for kernel.org
984 * gitproxy = netcatter-2 for sample.xz
985 * gitproxy = netcatter-default
986 */
YOSHIFUJI Hideaki / 吉藤英明c3df8562005-11-22 03:18:23[diff] [blame]987 for_pos = strstr(value, " for ");
Junio C Hamanoe814bc42005-11-19 11:48:56[diff] [blame]988 if (!for_pos)
989 /* matches everybody */
990 matchlen = strlen(value);
991 else {
992 hostlen = strlen(for_pos + 5);
993 if (rhost_len < hostlen)
994 matchlen = -1;
995 else if (!strncmp(for_pos + 5,
996 rhost_name + rhost_len - hostlen,
997 hostlen) &&
998 ((rhost_len == hostlen) ||
999 rhost_name[rhost_len - hostlen -1] == '.'))
1000 matchlen = for_pos - value;
1001 else
1002 matchlen = -1;
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]1003 }
Junio C Hamanoe814bc42005-11-19 11:48:56[diff] [blame]1004 if (0 <= matchlen) {
1005 /* core.gitproxy = none for kernel.org */
Junio C Hamanoa6080a02007-06-07 07:04:01[diff] [blame]1006 if (matchlen == 4 &&
Junio C Hamanoe814bc42005-11-19 11:48:56[diff] [blame]1007 !memcmp(value, "none", 4))
1008 matchlen = 0;
Pierre Habouzit182af832007-09-15 22:32:36[diff] [blame]1009 git_proxy_command = xmemdupz(value, matchlen);
Junio C Hamanoe814bc42005-11-19 11:48:56[diff] [blame]1010 }
1011 return 0;
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]1012 }
1013
Glen Chooa4e7e312023-06-28 19:26:22[diff] [blame]1014 return git_default_config(var, value, ctx, cb);
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]1015}
1016
Junio C Hamanoe814bc42005-11-19 11:48:56[diff] [blame]1017static int git_use_proxy(const char *host)
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]1018{
1019 git_proxy_command = getenv("GIT_PROXY_COMMAND");
Erik Faye-Lund15112c92009-03-11 02:38:12[diff] [blame]1020 git_config(git_proxy_command_options, (void*)host);
Junio C Hamanoe814bc42005-11-19 11:48:56[diff] [blame]1021 return (git_proxy_command && *git_proxy_command);
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]1022}
1023
Jeff King5cbf8242011-05-16 06:46:07[diff] [blame]1024static struct child_process *git_proxy_connect(int fd[2], char *host)
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]1025{
Timo Hirvonen554fe202006-06-28 09:04:39[diff] [blame]1026 const char *port = STR(DEFAULT_GIT_PORT);
Jeff King5cbf8242011-05-16 06:46:07[diff] [blame]1027 struct child_process *proxy;
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]1028
Michael Lukashov72a534d2010-02-17 20:56:02[diff] [blame]1029 get_host_and_port(&host, &port);
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]1030
Jeff King3be4cf02017-07-28 19:26:50[diff] [blame]1031 if (looks_like_command_line_option(host))
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]1032 die(_("strange hostname '%s' blocked"), host);
Jeff King3be4cf02017-07-28 19:26:50[diff] [blame]1033 if (looks_like_command_line_option(port))
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]1034 die(_("strange port '%s' blocked"), port);
Jeff King3be4cf02017-07-28 19:26:50[diff] [blame]1035
René Scharfe483bbd42014-08-19 19:10:48[diff] [blame]1036 proxy = xmalloc(sizeof(*proxy));
1037 child_process_init(proxy);
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1038 strvec_push(&proxy->args, git_proxy_command);
1039 strvec_push(&proxy->args, host);
1040 strvec_push(&proxy->args, port);
Jeff King5cbf8242011-05-16 06:46:07[diff] [blame]1041 proxy->in = -1;
1042 proxy->out = -1;
1043 if (start_command(proxy))
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]1044 die(_("cannot start proxy %s"), git_proxy_command);
Jeff King5cbf8242011-05-16 06:46:07[diff] [blame]1045 fd[0] = proxy->out; /* read from proxy stdout */
1046 fd[1] = proxy->in; /* write to proxy stdin */
1047 return proxy;
Paul Collinsf8014772005-11-04 14:57:16[diff] [blame]1048}
1049
Torsten Bögershausen86ceb332015-02-21 15:52:48[diff] [blame]1050static char *get_port(char *host)
Luben Tuikov2e776662007-09-01 09:36:31[diff] [blame]1051{
1052 char *end;
Torsten Bögershausen86ceb332015-02-21 15:52:48[diff] [blame]1053 char *p = strchr(host, ':');
1054
Luben Tuikov2e776662007-09-01 09:36:31[diff] [blame]1055 if (p) {
René Scharfe8f148252008-12-21 01:12:11[diff] [blame]1056 long port = strtol(p + 1, &end, 10);
1057 if (end != p + 1 && *end == '\0' && 0 <= port && port < 65536) {
Torsten Bögershausen86ceb332015-02-21 15:52:48[diff] [blame]1058 *p = '\0';
1059 return p+1;
Luben Tuikov2e776662007-09-01 09:36:31[diff] [blame]1060 }
1061 }
1062
1063 return NULL;
1064}
1065
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1066/*
Johannes Sixtcabc3c12013-11-28 19:49:01[diff] [blame]1067 * Extract protocol and relevant parts from the specified connection URL.
1068 * The caller must free() the returned strings.
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1069 */
Johannes Sixtcabc3c12013-11-28 19:49:01[diff] [blame]1070static enum protocol parse_connect_url(const char *url_orig, char **ret_host,
Torsten Bögershausen83b05872013-11-28 19:49:54[diff] [blame]1071 char **ret_path)
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1072{
Jeff King9d2e9422010-05-23 09:19:44[diff] [blame]1073 char *url;
Benjamin Kramer8e76bf32009-03-13 12:51:33[diff] [blame]1074 char *host, *path;
YOSHIFUJI Hideaki / 吉藤英明356bece2005-12-21 10:23:42[diff] [blame]1075 char *end;
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]1076 int separator = '/';
Andreas Ericssonfaea9cc2005-11-17 19:37:14[diff] [blame]1077 enum protocol protocol = PROTO_LOCAL;
Junio C Hamanof0b73672006-06-20 01:25:21[diff] [blame]1078
Jeff King9d2e9422010-05-23 09:19:44[diff] [blame]1079 if (is_url(url_orig))
1080 url = url_decode(url_orig);
1081 else
1082 url = xstrdup(url_orig);
1083
Andreas Ericssonfaea9cc2005-11-17 19:37:14[diff] [blame]1084 host = strstr(url, "://");
Brian Gianforcaroeeefa7c2009-09-01 05:35:10[diff] [blame]1085 if (host) {
Andreas Ericssonfaea9cc2005-11-17 19:37:14[diff] [blame]1086 *host = '\0';
1087 protocol = get_protocol(url);
1088 host += 3;
YOSHIFUJI Hideaki / 吉藤英明356bece2005-12-21 10:23:42[diff] [blame]1089 } else {
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1090 host = url;
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]1091 if (!url_is_local_not_ssh(url)) {
1092 protocol = PROTO_SSH;
1093 separator = ':';
1094 }
YOSHIFUJI Hideaki / 吉藤英明356bece2005-12-21 10:23:42[diff] [blame]1095 }
1096
Ilari Liusvaara9aa50532010-01-26 18:24:42[diff] [blame]1097 /*
Torsten Bögershausen83b05872013-11-28 19:49:54[diff] [blame]1098 * Don't do destructive transforms as protocol code does
1099 * '[]' unwrapping in get_host_and_port()
Ilari Liusvaara9aa50532010-01-26 18:24:42[diff] [blame]1100 */
Torsten Bögershausen86ceb332015-02-21 15:52:48[diff] [blame]1101 end = host_end(&host, 0);
YOSHIFUJI Hideaki / 吉藤英明356bece2005-12-21 10:23:42[diff] [blame]1102
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]1103 if (protocol == PROTO_LOCAL)
Linus Torvalds72a4f4b2007-08-01 17:03:37[diff] [blame]1104 path = end;
Torsten Bögershausenebb8d2c2019-08-24 22:07:59[diff] [blame]1105 else if (protocol == PROTO_FILE && *host != '/' &&
1106 !has_dos_drive_prefix(host) &&
1107 offset_1st_component(host - 2) > 1)
1108 path = host - 2; /* include the leading "//" */
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]1109 else if (protocol == PROTO_FILE && has_dos_drive_prefix(end))
1110 path = end; /* "file://$(pwd)" may be "file://C:/projects/repo" */
1111 else
1112 path = strchr(end, separator);
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]1113
Andreas Ericssonfaea9cc2005-11-17 19:37:14[diff] [blame]1114 if (!path || !*path)
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]1115 die(_("no path specified; see 'git help pull' for valid url syntax"));
Andreas Ericssonfaea9cc2005-11-17 19:37:14[diff] [blame]1116
1117 /*
1118 * null-terminate hostname and point path to ~ for URL's like this:
1119 * ssh://host.xz/~user/repo
1120 */
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]1121
1122 end = path; /* Need to \0 terminate host here */
1123 if (separator == ':')
1124 path++; /* path starts after ':' */
1125 if (protocol == PROTO_GIT || protocol == PROTO_SSH) {
Andreas Ericssonfaea9cc2005-11-17 19:37:14[diff] [blame]1126 if (path[1] == '~')
1127 path++;
Andreas Ericssonfaea9cc2005-11-17 19:37:14[diff] [blame]1128 }
1129
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]1130 path = xstrdup(path);
1131 *end = '\0';
1132
Johannes Sixtcabc3c12013-11-28 19:49:01[diff] [blame]1133 *ret_host = xstrdup(host);
Torsten Bögershausenc59ab2e2013-11-28 19:50:03[diff] [blame]1134 *ret_path = path;
Johannes Sixtcabc3c12013-11-28 19:49:01[diff] [blame]1135 free(url);
1136 return protocol;
1137}
1138
Nguyễn Thái Ngọc Duy3c8ede32016-06-26 11:16:35[diff] [blame]1139static const char *get_ssh_command(void)
1140{
1141 const char *ssh;
1142
1143 if ((ssh = getenv("GIT_SSH_COMMAND")))
1144 return ssh;
1145
Jeff Kingf1de9812020-08-14 16:17:36[diff] [blame]1146 if (!git_config_get_string_tmp("core.sshcommand", &ssh))
Nguyễn Thái Ngọc Duy3c8ede32016-06-26 11:16:35[diff] [blame]1147 return ssh;
1148
1149 return NULL;
1150}
1151
Brandon Williams94b8ae52017-10-16 17:55:31[diff] [blame]1152enum ssh_variant {
Jonathan Nieder0da0e492017-11-20 21:30:04[diff] [blame]1153 VARIANT_AUTO,
Brandon Williams94b8ae52017-10-16 17:55:31[diff] [blame]1154 VARIANT_SIMPLE,
1155 VARIANT_SSH,
1156 VARIANT_PLINK,
1157 VARIANT_PUTTY,
1158 VARIANT_TORTOISEPLINK,
1159};
Junio C Hamano486c8e82017-02-09 17:20:25[diff] [blame]1160
Jonathan Nieder0da0e492017-11-20 21:30:04[diff] [blame]1161static void override_ssh_variant(enum ssh_variant *ssh_variant)
Brandon Williams94b8ae52017-10-16 17:55:31[diff] [blame]1162{
1163 const char *variant = getenv("GIT_SSH_VARIANT");
1164
Jeff Kingf1de9812020-08-14 16:17:36[diff] [blame]1165 if (!variant && git_config_get_string_tmp("ssh.variant", &variant))
Jonathan Nieder0da0e492017-11-20 21:30:04[diff] [blame]1166 return;
Junio C Hamano486c8e82017-02-09 17:20:25[diff] [blame]1167
Jonathan Nieder0da0e492017-11-20 21:30:04[diff] [blame]1168 if (!strcmp(variant, "auto"))
1169 *ssh_variant = VARIANT_AUTO;
1170 else if (!strcmp(variant, "plink"))
Brandon Williams94b8ae52017-10-16 17:55:31[diff] [blame]1171 *ssh_variant = VARIANT_PLINK;
1172 else if (!strcmp(variant, "putty"))
1173 *ssh_variant = VARIANT_PUTTY;
1174 else if (!strcmp(variant, "tortoiseplink"))
1175 *ssh_variant = VARIANT_TORTOISEPLINK;
1176 else if (!strcmp(variant, "simple"))
1177 *ssh_variant = VARIANT_SIMPLE;
1178 else
1179 *ssh_variant = VARIANT_SSH;
Junio C Hamano486c8e82017-02-09 17:20:25[diff] [blame]1180}
1181
Brandon Williams94b8ae52017-10-16 17:55:31[diff] [blame]1182static enum ssh_variant determine_ssh_variant(const char *ssh_command,
1183 int is_cmdline)
Junio C Hamano486c8e82017-02-09 17:20:25[diff] [blame]1184{
Jonathan Nieder0da0e492017-11-20 21:30:04[diff] [blame]1185 enum ssh_variant ssh_variant = VARIANT_AUTO;
Junio C Hamano486c8e82017-02-09 17:20:25[diff] [blame]1186 const char *variant;
Johannes Schindeline2824e42017-02-01 12:01:10[diff] [blame]1187 char *p = NULL;
1188
Jonathan Nieder0da0e492017-11-20 21:30:04[diff] [blame]1189 override_ssh_variant(&ssh_variant);
1190
1191 if (ssh_variant != VARIANT_AUTO)
Brandon Williams94b8ae52017-10-16 17:55:31[diff] [blame]1192 return ssh_variant;
Junio C Hamano486c8e82017-02-09 17:20:25[diff] [blame]1193
1194 if (!is_cmdline) {
Johannes Schindeline2824e42017-02-01 12:01:10[diff] [blame]1195 p = xstrdup(ssh_command);
1196 variant = basename(p);
1197 } else {
1198 const char **ssh_argv;
1199
1200 p = xstrdup(ssh_command);
Jeff King22e5ae52017-04-11 00:30:23[diff] [blame]1201 if (split_cmdline(p, &ssh_argv) > 0) {
Johannes Schindeline2824e42017-02-01 12:01:10[diff] [blame]1202 variant = basename((char *)ssh_argv[0]);
1203 /*
1204 * At this point, variant points into the buffer
1205 * referenced by p, hence we do not need ssh_argv
1206 * any longer.
1207 */
1208 free(ssh_argv);
Jeff King5d2993b2017-04-20 20:21:58[diff] [blame]1209 } else {
1210 free(p);
Brandon Williams94b8ae52017-10-16 17:55:31[diff] [blame]1211 return ssh_variant;
Jeff King5d2993b2017-04-20 20:21:58[diff] [blame]1212 }
Johannes Schindeline2824e42017-02-01 12:01:10[diff] [blame]1213 }
1214
Brandon Williams94b8ae52017-10-16 17:55:31[diff] [blame]1215 if (!strcasecmp(variant, "ssh") ||
1216 !strcasecmp(variant, "ssh.exe"))
1217 ssh_variant = VARIANT_SSH;
1218 else if (!strcasecmp(variant, "plink") ||
1219 !strcasecmp(variant, "plink.exe"))
1220 ssh_variant = VARIANT_PLINK;
Johannes Schindeline2824e42017-02-01 12:01:10[diff] [blame]1221 else if (!strcasecmp(variant, "tortoiseplink") ||
Brandon Williams94b8ae52017-10-16 17:55:31[diff] [blame]1222 !strcasecmp(variant, "tortoiseplink.exe"))
1223 ssh_variant = VARIANT_TORTOISEPLINK;
1224
Johannes Schindeline2824e42017-02-01 12:01:10[diff] [blame]1225 free(p);
Brandon Williams94b8ae52017-10-16 17:55:31[diff] [blame]1226 return ssh_variant;
Johannes Schindeline2824e42017-02-01 12:01:10[diff] [blame]1227}
1228
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1229/*
Jonathan Nieder2ac67cb2017-11-20 21:23:27[diff] [blame]1230 * Open a connection using Git's native protocol.
1231 *
1232 * The caller is responsible for freeing hostandport, but this function may
1233 * modify it (for example, to truncate it to remove the port part).
1234 */
1235static struct child_process *git_connect_git(int fd[2], char *hostandport,
1236 const char *path, const char *prog,
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1237 enum protocol_version version,
Jonathan Nieder2ac67cb2017-11-20 21:23:27[diff] [blame]1238 int flags)
1239{
1240 struct child_process *conn;
1241 struct strbuf request = STRBUF_INIT;
1242 /*
1243 * Set up virtual host information based on where we will
1244 * connect, unless the user has overridden us in
1245 * the environment.
1246 */
1247 char *target_host = getenv("GIT_OVERRIDE_VIRTUAL_HOST");
1248 if (target_host)
1249 target_host = xstrdup(target_host);
1250 else
1251 target_host = xstrdup(hostandport);
1252
1253 transport_check_allowed("git");
Jeff Kinga02ea572021-01-07 09:43:58[diff] [blame]1254 if (strchr(target_host, '\n') || strchr(path, '\n'))
1255 die(_("newline is forbidden in git:// hosts and repo paths"));
Jonathan Nieder2ac67cb2017-11-20 21:23:27[diff] [blame]1256
Jonathan Nieder233cd282017-11-20 22:04:58[diff] [blame]1257 /*
1258 * These underlying connection commands die() if they
Jonathan Nieder2ac67cb2017-11-20 21:23:27[diff] [blame]1259 * cannot connect.
1260 */
1261 if (git_use_proxy(hostandport))
1262 conn = git_proxy_connect(fd, hostandport);
1263 else
1264 conn = git_tcp_connect(fd, hostandport, flags);
1265 /*
1266 * Separate original protocol components prog and path
1267 * from extended host header with a NUL byte.
1268 *
1269 * Note: Do not add any other headers here! Doing so
1270 * will cause older git-daemon servers to crash.
1271 */
1272 strbuf_addf(&request,
1273 "%s %s%chost=%s%c",
1274 prog, path, 0,
1275 target_host, 0);
1276
1277 /* If using a new version put that stuff here after a second null byte */
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1278 if (version > 0) {
Jonathan Nieder2ac67cb2017-11-20 21:23:27[diff] [blame]1279 strbuf_addch(&request, '\0');
1280 strbuf_addf(&request, "version=%d%c",
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1281 version, '\0');
Jonathan Nieder2ac67cb2017-11-20 21:23:27[diff] [blame]1282 }
1283
1284 packet_write(fd[1], request.buf, request.len);
1285
1286 free(target_host);
1287 strbuf_release(&request);
1288 return conn;
1289}
1290
Jonathan Nieder957e2ad2017-11-20 21:26:19[diff] [blame]1291/*
1292 * Append the appropriate environment variables to `env` and options to
1293 * `args` for running ssh in Git's SSH-tunneled transport.
1294 */
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1295static void push_ssh_options(struct strvec *args, struct strvec *env,
Jonathan Nieder957e2ad2017-11-20 21:26:19[diff] [blame]1296 enum ssh_variant variant, const char *port,
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1297 enum protocol_version version, int flags)
Jonathan Nieder957e2ad2017-11-20 21:26:19[diff] [blame]1298{
1299 if (variant == VARIANT_SSH &&
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1300 version > 0) {
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1301 strvec_push(args, "-o");
1302 strvec_push(args, "SendEnv=" GIT_PROTOCOL_ENVIRONMENT);
1303 strvec_pushf(env, GIT_PROTOCOL_ENVIRONMENT "=version=%d",
Jeff Kingf6d89422020-07-28 20:26:31[diff] [blame]1304 version);
Jonathan Nieder957e2ad2017-11-20 21:26:19[diff] [blame]1305 }
1306
Jonathan Niedera3f5b662017-11-20 21:30:30[diff] [blame]1307 if (flags & CONNECT_IPV4) {
1308 switch (variant) {
1309 case VARIANT_AUTO:
1310 BUG("VARIANT_AUTO passed to push_ssh_options");
1311 case VARIANT_SIMPLE:
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]1312 die(_("ssh variant 'simple' does not support -4"));
Jonathan Niedera3f5b662017-11-20 21:30:30[diff] [blame]1313 case VARIANT_SSH:
1314 case VARIANT_PLINK:
1315 case VARIANT_PUTTY:
1316 case VARIANT_TORTOISEPLINK:
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1317 strvec_push(args, "-4");
Jonathan Niedera3f5b662017-11-20 21:30:30[diff] [blame]1318 }
1319 } else if (flags & CONNECT_IPV6) {
1320 switch (variant) {
1321 case VARIANT_AUTO:
1322 BUG("VARIANT_AUTO passed to push_ssh_options");
1323 case VARIANT_SIMPLE:
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]1324 die(_("ssh variant 'simple' does not support -6"));
Jonathan Niedera3f5b662017-11-20 21:30:30[diff] [blame]1325 case VARIANT_SSH:
1326 case VARIANT_PLINK:
1327 case VARIANT_PUTTY:
1328 case VARIANT_TORTOISEPLINK:
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1329 strvec_push(args, "-6");
Jonathan Niedera3f5b662017-11-20 21:30:30[diff] [blame]1330 }
Jonathan Nieder957e2ad2017-11-20 21:26:19[diff] [blame]1331 }
1332
1333 if (variant == VARIANT_TORTOISEPLINK)
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1334 strvec_push(args, "-batch");
Jonathan Nieder957e2ad2017-11-20 21:26:19[diff] [blame]1335
Jonathan Nieder3fa5e0d2017-11-20 21:31:01[diff] [blame]1336 if (port) {
1337 switch (variant) {
1338 case VARIANT_AUTO:
1339 BUG("VARIANT_AUTO passed to push_ssh_options");
1340 case VARIANT_SIMPLE:
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]1341 die(_("ssh variant 'simple' does not support setting port"));
Jonathan Nieder3fa5e0d2017-11-20 21:31:01[diff] [blame]1342 case VARIANT_SSH:
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1343 strvec_push(args, "-p");
Jonathan Nieder3fa5e0d2017-11-20 21:31:01[diff] [blame]1344 break;
1345 case VARIANT_PLINK:
1346 case VARIANT_PUTTY:
1347 case VARIANT_TORTOISEPLINK:
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1348 strvec_push(args, "-P");
Jonathan Nieder3fa5e0d2017-11-20 21:31:01[diff] [blame]1349 }
Jonathan Nieder957e2ad2017-11-20 21:26:19[diff] [blame]1350
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1351 strvec_push(args, port);
Jonathan Nieder957e2ad2017-11-20 21:26:19[diff] [blame]1352 }
1353}
1354
Jonathan Niederfce54ce2017-11-20 22:19:43[diff] [blame]1355/* Prepare a child_process for use by Git's SSH-tunneled transport. */
1356static void fill_ssh_args(struct child_process *conn, const char *ssh_host,
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1357 const char *port, enum protocol_version version,
1358 int flags)
Jonathan Niederfce54ce2017-11-20 22:19:43[diff] [blame]1359{
1360 const char *ssh;
1361 enum ssh_variant variant;
1362
1363 if (looks_like_command_line_option(ssh_host))
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]1364 die(_("strange hostname '%s' blocked"), ssh_host);
Jonathan Niederfce54ce2017-11-20 22:19:43[diff] [blame]1365
1366 ssh = get_ssh_command();
1367 if (ssh) {
1368 variant = determine_ssh_variant(ssh, 1);
1369 } else {
1370 /*
1371 * GIT_SSH is the no-shell version of
1372 * GIT_SSH_COMMAND (and must remain so for
1373 * historical compatibility).
1374 */
1375 conn->use_shell = 0;
1376
1377 ssh = getenv("GIT_SSH");
1378 if (!ssh)
1379 ssh = "ssh";
1380 variant = determine_ssh_variant(ssh, 0);
1381 }
1382
Jonathan Nieder0da0e492017-11-20 21:30:04[diff] [blame]1383 if (variant == VARIANT_AUTO) {
1384 struct child_process detect = CHILD_PROCESS_INIT;
1385
1386 detect.use_shell = conn->use_shell;
1387 detect.no_stdin = detect.no_stdout = detect.no_stderr = 1;
1388
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1389 strvec_push(&detect.args, ssh);
1390 strvec_push(&detect.args, "-G");
Ævar Arnfjörð Bjarmason29fda242022-06-02 09:09:50[diff] [blame]1391 push_ssh_options(&detect.args, &detect.env,
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1392 VARIANT_SSH, port, version, flags);
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1393 strvec_push(&detect.args, ssh_host);
Jonathan Nieder0da0e492017-11-20 21:30:04[diff] [blame]1394
1395 variant = run_command(&detect) ? VARIANT_SIMPLE : VARIANT_SSH;
1396 }
1397
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1398 strvec_push(&conn->args, ssh);
Ævar Arnfjörð Bjarmason29fda242022-06-02 09:09:50[diff] [blame]1399 push_ssh_options(&conn->args, &conn->env, variant, port, version,
1400 flags);
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1401 strvec_push(&conn->args, ssh_host);
Jonathan Niederfce54ce2017-11-20 22:19:43[diff] [blame]1402}
1403
Jonathan Nieder2ac67cb2017-11-20 21:23:27[diff] [blame]1404/*
Jonathan Nieder8e349782017-11-20 21:22:54[diff] [blame]1405 * This returns the dummy child_process `no_fork` if the transport protocol
1406 * does not need fork(2), or a struct child_process object if it does. Once
1407 * done, finish the connection with finish_connect() with the value returned
1408 * from this function (it is safe to call finish_connect() with NULL to
1409 * support the former case).
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1410 *
1411 * If it returns, the connect is successful; it just dies on errors (this
1412 * will hopefully be changed in a libification effort, to return NULL when
1413 * the connection failed).
1414 */
Johannes Sixtcabc3c12013-11-28 19:49:01[diff] [blame]1415struct child_process *git_connect(int fd[2], const char *url,
Jeff Kingeaa0fd62023-03-17 19:08:51[diff] [blame]1416 const char *name,
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1417 const char *prog, int flags)
1418{
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1419 char *hostandport, *path;
Jonathan Nieder8e349782017-11-20 21:22:54[diff] [blame]1420 struct child_process *conn;
Johannes Sixtcabc3c12013-11-28 19:49:01[diff] [blame]1421 enum protocol protocol;
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1422 enum protocol_version version = get_protocol_version_config();
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1423
Brandon Williams1aa8dded2018-03-15 17:31:31[diff] [blame]1424 /*
1425 * NEEDSWORK: If we are trying to use protocol v2 and we are planning
Jeff Kingeaa0fd62023-03-17 19:08:51[diff] [blame]1426 * to perform any operation that doesn't involve upload-pack (i.e., a
1427 * fetch, ls-remote, etc), then fallback to v0 since we don't know how
1428 * to do anything else (like push or remote archive) via v2.
Brandon Williams1aa8dded2018-03-15 17:31:31[diff] [blame]1429 */
Jeff Kingeaa0fd62023-03-17 19:08:51[diff] [blame]1430 if (version == protocol_v2 && strcmp("git-upload-pack", name))
Brandon Williams1aa8dded2018-03-15 17:31:31[diff] [blame]1431 version = protocol_v0;
1432
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1433 /* Without this we cannot rely on waitpid() to tell
1434 * what happened to our children.
1435 */
1436 signal(SIGCHLD, SIG_DFL);
1437
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1438 protocol = parse_connect_url(url, &hostandport, &path);
Torsten Bögershausen3f55cca2015-02-21 15:52:55[diff] [blame]1439 if ((flags & CONNECT_DIAG_URL) && (protocol != PROTO_SSH)) {
Torsten Bögershausen5610b7c2013-11-28 19:49:17[diff] [blame]1440 printf("Diag: url=%s\n", url ? url : "NULL");
1441 printf("Diag: protocol=%s\n", prot_name(protocol));
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1442 printf("Diag: hostandport=%s\n", hostandport ? hostandport : "NULL");
Torsten Bögershausen5610b7c2013-11-28 19:49:17[diff] [blame]1443 printf("Diag: path=%s\n", path ? path : "NULL");
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1444 conn = NULL;
1445 } else if (protocol == PROTO_GIT) {
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1446 conn = git_connect_git(fd, hostandport, path, prog, version, flags);
Jeff Hostetlerabd81a32019-02-22 22:25:05[diff] [blame]1447 conn->trace2_child_class = "transport/git";
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1448 } else {
Rene Scharfef1399292017-08-30 17:49:39[diff] [blame]1449 struct strbuf cmd = STRBUF_INIT;
Brandon Williams0c2f0d22017-10-16 17:55:28[diff] [blame]1450 const char *const *var;
Rene Scharfef1399292017-08-30 17:49:39[diff] [blame]1451
René Scharfe483bbd42014-08-19 19:10:48[diff] [blame]1452 conn = xmalloc(sizeof(*conn));
1453 child_process_init(conn);
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1454
Jeff Kingaeeb2d42017-07-28 19:28:55[diff] [blame]1455 if (looks_like_command_line_option(path))
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]1456 die(_("strange pathname '%s' blocked"), path);
Jeff Kingaeeb2d42017-07-28 19:28:55[diff] [blame]1457
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1458 strbuf_addstr(&cmd, prog);
1459 strbuf_addch(&cmd, ' ');
1460 sq_quote_buf(&cmd, path);
Christian Couder0f503d72006-09-11 05:04:50[diff] [blame]1461
Jeff Kingaab40432015-09-04 22:40:08[diff] [blame]1462 /* remove repo-local variables from the environment */
Brandon Williams0c2f0d22017-10-16 17:55:28[diff] [blame]1463 for (var = local_repo_env; *var; var++)
Ævar Arnfjörð Bjarmason29fda242022-06-02 09:09:50[diff] [blame]1464 strvec_push(&conn->env, *var);
Brandon Williams0c2f0d22017-10-16 17:55:28[diff] [blame]1465
Jeff Kinga48b4092015-09-08 08:33:14[diff] [blame]1466 conn->use_shell = 1;
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1467 conn->in = conn->out = -1;
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1468 if (protocol == PROTO_SSH) {
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1469 char *ssh_host = hostandport;
1470 const char *port = NULL;
Jeff Kinga5adace2015-09-16 17:12:52[diff] [blame]1471 transport_check_allowed("ssh");
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1472 get_host_and_port(&ssh_host, &port);
Christian Couder0f503d72006-09-11 05:04:50[diff] [blame]1473
Torsten Bögershausen86ceb332015-02-21 15:52:48[diff] [blame]1474 if (!port)
1475 port = get_port(ssh_host);
Junio C Hamano42da4842015-03-05 20:45:44[diff] [blame]1476
Torsten Bögershausen3f55cca2015-02-21 15:52:55[diff] [blame]1477 if (flags & CONNECT_DIAG_URL) {
1478 printf("Diag: url=%s\n", url ? url : "NULL");
1479 printf("Diag: protocol=%s\n", prot_name(protocol));
1480 printf("Diag: userandhost=%s\n", ssh_host ? ssh_host : "NULL");
1481 printf("Diag: port=%s\n", port ? port : "NONE");
1482 printf("Diag: path=%s\n", path ? path : "NULL");
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1483
Torsten Bögershausen3f55cca2015-02-21 15:52:55[diff] [blame]1484 free(hostandport);
1485 free(path);
Stefan Beller04f20c02015-03-09 16:58:22[diff] [blame]1486 free(conn);
Rene Scharfef1399292017-08-30 17:49:39[diff] [blame]1487 strbuf_release(&cmd);
Torsten Bögershausen3f55cca2015-02-21 15:52:55[diff] [blame]1488 return NULL;
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1489 }
Jeff Hostetlerabd81a32019-02-22 22:25:05[diff] [blame]1490 conn->trace2_child_class = "transport/ssh";
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1491 fill_ssh_args(conn, ssh_host, port, version, flags);
Nguyễn Thái Ngọc Duyc049b612014-03-13 11:45:31[diff] [blame]1492 } else {
Jeff Kinga5adace2015-09-16 17:12:52[diff] [blame]1493 transport_check_allowed("file");
Jeff Hostetlerabd81a32019-02-22 22:25:05[diff] [blame]1494 conn->trace2_child_class = "transport/file";
Brandon Williams40fc51e2018-03-15 17:31:30[diff] [blame]1495 if (version > 0) {
Ævar Arnfjörð Bjarmason29fda242022-06-02 09:09:50[diff] [blame]1496 strvec_pushf(&conn->env,
Jeff Kingf6d89422020-07-28 20:26:31[diff] [blame]1497 GIT_PROTOCOL_ENVIRONMENT "=version=%d",
1498 version);
Brandon Williams0c2f0d22017-10-16 17:55:28[diff] [blame]1499 }
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1500 }
Jeff Kingef8d7ac2020-07-28 20:24:53[diff] [blame]1501 strvec_push(&conn->args, cmd.buf);
Johannes Sixtf364cb82007-10-19 19:47:54[diff] [blame]1502
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1503 if (start_command(conn))
Nguyễn Thái Ngọc Duyaad6fdd2018-07-21 07:49:28[diff] [blame]1504 die(_("unable to fork"));
Johannes Sixtf364cb82007-10-19 19:47:54[diff] [blame]1505
Torsten Bögershausena2036d72013-11-28 19:50:15[diff] [blame]1506 fd[0] = conn->out; /* read from child's stdout */
1507 fd[1] = conn->in; /* write to child's stdin */
1508 strbuf_release(&cmd);
1509 }
1510 free(hostandport);
Johannes Sixtcabc3c12013-11-28 19:49:01[diff] [blame]1511 free(path);
Johannes Sixt98158e92007-10-19 19:47:53[diff] [blame]1512 return conn;
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1513}
1514
Johannes Sixt98158e92007-10-19 19:47:53[diff] [blame]1515int finish_connect(struct child_process *conn)
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1516{
Johannes Sixtf364cb82007-10-19 19:47:54[diff] [blame]1517 int code;
Jeff King7ffe8532011-05-16 06:52:11[diff] [blame]1518 if (!conn || git_connection_is_socket(conn))
Franck Bui-Huuf42a5c42006-09-12 09:00:13[diff] [blame]1519 return 0;
1520
Johannes Sixtf364cb82007-10-19 19:47:54[diff] [blame]1521 code = finish_command(conn);
Johannes Sixt98158e92007-10-19 19:47:53[diff] [blame]1522 free(conn);
Johannes Sixtf364cb82007-10-19 19:47:54[diff] [blame]1523 return code;
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]1524}