Public Git Hosting - git/debian.git/blob

1 #include "git-compat-util.h"

2 #include "cache.h"

3 #include "config.h"

4 #include "pkt-line.h"

5 #include "quote.h"

6 #include "refs.h"

7 #include "run-command.h"

8 #include "remote.h"

9 #include "connect.h"

10 #include "url.h"

11 #include "string-list.h"

12 #include "oid-array.h"

13 #include "transport.h"

14 #include "strbuf.h"

15 #include "version.h"

16 #include "protocol.h"

17 #include "alias.h"

19 static char *server_capabilities_v1;

20 static struct strvec server_capabilities_v2 = STRVEC_INIT;

static const char *next_server_feature_value(const char *feature, int *len, int *offset);

static int check_ref(const char *name, unsigned int flags)

24 {

25 if (!flags)

26 return 1;

        if (!skip_prefix(name, "refs/", &name))

29 return 0;

31 /* REF_NORMAL means that we don't want the magic fake tag refs */

        if ((flags & REF_NORMAL) && check_refname_format(name, 0))

33 return 0;

35 /* REF_HEADS means that we want regular branch heads */

        if ((flags & REF_HEADS) && starts_with(name, "heads/"))

37 return 1;

39 /* REF_TAGS means that we want tags */

        if ((flags & REF_TAGS) && starts_with(name, "tags/"))

41 return 1;

43 /* All type bits clear means that we are ok with anything */

44 return !(flags & ~REF_NORMAL);

45 }

int check_ref_type(const struct ref *ref, int flags)

48 {

        return check_ref(ref->name, flags);

50 }

static NORETURN void die_initial_contact(int unexpected)

53 {

54 /*

55 * A hang-up after seeing some response from the other end

56 * means that it is unexpected, as we know the other end is

57 * willing to talk to us. A hang-up before seeing any

58 * response does not necessarily mean an ACL problem, though.

59 */

60 if (unexpected)

                die(_("the remote end hung up upon initial contact"));

62 else

                die(_("Could not read from remote repository.\n\n"

64 "Please make sure you have the correct access rights\n"

65 "and the repository exists."));

66 }

68 /* Checks if the server supports the capability 'c' */

int server_supports_v2(const char *c)

70 {

71 int i;

        for (i = 0; i < server_capabilities_v2.nr; i  ) {

74 const char *out;

                if (skip_prefix(server_capabilities_v2.v[i], c, &out) &&

                    (!*out || *out == '='))

77 return 1;

78 }

79 return 0;

80 }

void ensure_server_supports_v2(const char *c)

83 {

        if (!server_supports_v2(c))

                die(_("server doesn't support '%s'"), c);

86 }

int server_feature_v2(const char *c, const char **v)

89 {

90 int i;

        for (i = 0; i < server_capabilities_v2.nr; i  ) {

93 const char *out;

                if (skip_prefix(server_capabilities_v2.v[i], c, &out) &&

95 (*out == '=')) {

                        *v = out   1;

97 return 1;

98 }

99 }

100 return 0;

101 }

102

int server_supports_feature(const char *c, const char *feature,

104 int die_on_error)

105 {

106 int i;

107

        for (i = 0; i < server_capabilities_v2.nr; i  ) {

109 const char *out;

                if (skip_prefix(server_capabilities_v2.v[i], c, &out) &&

                    (!*out || *(out  ) == '=')) {

                        if (parse_feature_request(out, feature))

113 return 1;

114 else

115 break;

116 }

117 }

118

119 if (die_on_error)

                die(_("server doesn't support feature '%s'"), feature);

121

122 return 0;

123 }

124

static void process_capabilities_v2(struct packet_reader *reader)

126 {

        while (packet_reader_read(reader) == PACKET_READ_NORMAL)

                strvec_push(&server_capabilities_v2, reader->line);

129

        if (reader->status != PACKET_READ_FLUSH)

                die(_("expected flush after capabilities"));

132 }

133

enum protocol_version discover_version(struct packet_reader *reader)

135 {

136 enum protocol_version version = protocol_unknown_version;

137

138 /*

139 * Peek the first line of the server's response to

140 * determine the protocol version the server is speaking.

141 */

        switch (packet_reader_peek(reader)) {

143 case PACKET_READ_EOF:

144 die_initial_contact(0);

145 case PACKET_READ_FLUSH:

146 case PACKET_READ_DELIM:

147 case PACKET_READ_RESPONSE_END:

148 version = protocol_v0;

149 break;

150 case PACKET_READ_NORMAL:

                version = determine_protocol_version_client(reader->line);

152 break;

153 }

154

155 switch (version) {

156 case protocol_v2:

157 process_capabilities_v2(reader);

158 break;

159 case protocol_v1:

160 /* Read the peeked version line */

161 packet_reader_read(reader);

162 break;

163 case protocol_v0:

164 break;

165 case protocol_unknown_version:

166 BUG("unknown protocol version");

167 }

168

        trace2_data_intmax("transfer", NULL, "negotiated-version", version);

170

171 return version;

172 }

173

static void parse_one_symref_info(struct string_list *symref, const char *val, int len)

175 {

176 char *sym, *target;

177 struct string_list_item *item;

178

179 if (!len)

180 return; /* just "symref" */

181 /* e.g. "symref=HEAD:refs/heads/master" */

        sym = xmemdupz(val, len);

        target = strchr(sym, ':');

184 if (!target)

185 /* just "symref=something" */

186 goto reject;

187 *(target ) = '\0';

        if (check_refname_format(sym, REFNAME_ALLOW_ONELEVEL) ||

189 check_refname_format(target, REFNAME_ALLOW_ONELEVEL))

190 /* "symref=bogus:pair */

191 goto reject;

        item = string_list_append_nodup(symref, sym);

193 item->util = target;

194 return;

195 reject:

196 free(sym);

197 return;

198 }

199

static void annotate_refs_with_symref_info(struct ref *ref)

201 {

202 struct string_list symref = STRING_LIST_INIT_DUP;

203 int offset = 0;

204

205 while (1) {

206 int len;

207 const char *val;

208

                val = next_server_feature_value("symref", &len, &offset);

210 if (!val)

211 break;

                parse_one_symref_info(&symref, val, len);

213 }

214 string_list_sort(&symref);

215

        for (; ref; ref = ref->next) {

217 struct string_list_item *item;

                item = string_list_lookup(&symref, ref->name);

219 if (!item)

220 continue;

                ref->symref = xstrdup((char *)item->util);

222 }

        string_list_clear(&symref, 0);

224 }

225

static void process_capabilities(struct packet_reader *reader, int *linelen)

227 {

228 const char *feat_val;

229 int feat_len;

        const char *line = reader->line;

        int nul_location = strlen(line);

232 if (nul_location == *linelen)

233 return;

        server_capabilities_v1 = xstrdup(line   nul_location   1);

235 *linelen = nul_location;

236

        feat_val = server_feature_value("object-format", &feat_len);

238 if (feat_val) {

                char *hash_name = xstrndup(feat_val, feat_len);

                int hash_algo = hash_algo_by_name(hash_name);

241 if (hash_algo != GIT_HASH_UNKNOWN)

242 reader->hash_algo = &hash_algos[hash_algo];

243 free(hash_name);

244 } else {

245 reader->hash_algo = &hash_algos[GIT_HASH_SHA1];

246 }

247 }

248

static int process_dummy_ref(const struct packet_reader *reader)

250 {

        const char *line = reader->line;

252 struct object_id oid;

253 const char *name;

254

        if (parse_oid_hex_algop(line, &oid, &name, reader->hash_algo))

256 return 0;

        if (*name != ' ')

258 return 0;

259 name ;

260

        return oideq(null_oid(), &oid) && !strcmp(name, "capabilities^{}");

262 }

263

static void check_no_capabilities(const char *line, int len)

265 {

        if (strlen(line) != len)

                warning(_("ignoring capabilities after first line '%s'"),

268 line strlen(line));

269 }

270

static int process_ref(const struct packet_reader *reader, int len,

                       struct ref ***list, unsigned int flags,

273 struct oid_array *extra_have)

274 {

        const char *line = reader->line;

276 struct object_id old_oid;

277 const char *name;

278

        if (parse_oid_hex_algop(line, &old_oid, &name, reader->hash_algo))

280 return 0;

        if (*name != ' ')

282 return 0;

283 name ;

284

        if (extra_have && !strcmp(name, ".have")) {

286 oid_array_append(extra_have, &old_oid);

        } else if (!strcmp(name, "capabilities^{}")) {

                die(_("protocol error: unexpected capabilities^{}"));

        } else if (check_ref(name, flags)) {

                struct ref *ref = alloc_ref(name);

                oidcpy(&ref->old_oid, &old_oid);

292 **list = ref;

293 *list = &ref->next;

294 }

295 check_no_capabilities(line, len);

296 return 1;

297 }

298

static int process_shallow(const struct packet_reader *reader, int len,

300 struct oid_array *shallow_points)

301 {

        const char *line = reader->line;

303 const char *arg;

304 struct object_id old_oid;

305

        if (!skip_prefix(line, "shallow ", &arg))

307 return 0;

308

        if (get_oid_hex_algop(arg, &old_oid, reader->hash_algo))

                die(_("protocol error: expected shallow sha-1, got '%s'"), arg);

311 if (!shallow_points)

                die(_("repository on the other end cannot be shallow"));

313 oid_array_append(shallow_points, &old_oid);

314 check_no_capabilities(line, len);

315 return 1;

316 }

317

318 enum get_remote_heads_state {

319 EXPECTING_FIRST_REF = 0,

320 EXPECTING_REF,

321 EXPECTING_SHALLOW,

322 EXPECTING_DONE,

323 };

324

325 /*

326 * Read all the refs from the other end

327 */

struct ref **get_remote_heads(struct packet_reader *reader,

                              struct ref **list, unsigned int flags,

330 struct oid_array *extra_have,

331 struct oid_array *shallow_points)

332 {

333 struct ref **orig_list = list;

334 int len = 0;

335 enum get_remote_heads_state state = EXPECTING_FIRST_REF;

336

337 *list = NULL;

338

339 while (state != EXPECTING_DONE) {

                switch (packet_reader_read(reader)) {

341 case PACKET_READ_EOF:

342 die_initial_contact(1);

343 case PACKET_READ_NORMAL:

344 len = reader->pktlen;

345 break;

346 case PACKET_READ_FLUSH:

347 state = EXPECTING_DONE;

348 break;

349 case PACKET_READ_DELIM:

350 case PACKET_READ_RESPONSE_END:

                        die(_("invalid packet"));

352 }

353

354 switch (state) {

355 case EXPECTING_FIRST_REF:

356 process_capabilities(reader, &len);

                        if (process_dummy_ref(reader)) {

358 state = EXPECTING_SHALLOW;

359 break;

360 }

361 state = EXPECTING_REF;

362 /* fallthrough */

363 case EXPECTING_REF:

                        if (process_ref(reader, len, &list, flags, extra_have))

365 break;

366 state = EXPECTING_SHALLOW;

367 /* fallthrough */

368 case EXPECTING_SHALLOW:

                        if (process_shallow(reader, len, shallow_points))

370 break;

                        die(_("protocol error: unexpected '%s'"), reader->line);

372 case EXPECTING_DONE:

373 break;

374 }

375 }

376

377 annotate_refs_with_symref_info(*orig_list);

378

379 return list;

380 }

381

382 /* Returns 1 when a valid ref has been added to `list`, 0 otherwise */

static int process_ref_v2(struct packet_reader *reader, struct ref ***list,

384 const char **unborn_head_target)

385 {

386 int ret = 1;

387 int i = 0;

388 struct object_id old_oid;

389 struct ref *ref;

390 struct string_list line_sections = STRING_LIST_INIT_DUP;

391 const char *end;

        const char *line = reader->line;

393

394 /*

395 * Ref lines have a number of fields which are space deliminated. The

396 * first field is the OID of the ref. The second field is the ref

397 * name. Subsequent fields (symref-target and peeled) are optional and

398 * don't have a particular order.

399 */

        if (string_list_split(&line_sections, line, ' ', -1) < 2) {

401 ret = 0;

402 goto out;

403 }

404

        if (!strcmp("unborn", line_sections.items[i].string)) {

406 i ;

407 if (unborn_head_target &&

                    !strcmp("HEAD", line_sections.items[i  ].string)) {

409 /*

410 * Look for the symref target (if any). If found,

411 * return it to the caller.

412 */

                        for (; i < line_sections.nr; i  ) {

                                const char *arg = line_sections.items[i].string;

415

                                if (skip_prefix(arg, "symref-target:", &arg)) {

                                        *unborn_head_target = xstrdup(arg);

418 break;

419 }

420 }

421 }

422 goto out;

423 }

        if (parse_oid_hex_algop(line_sections.items[i  ].string, &old_oid, &end, reader->hash_algo) ||

425 *end) {

426 ret = 0;

427 goto out;

428 }

429

        ref = alloc_ref(line_sections.items[i  ].string);

431

        memcpy(ref->old_oid.hash, old_oid.hash, reader->hash_algo->rawsz);

433 **list = ref;

434 *list = &ref->next;

435

        for (; i < line_sections.nr; i  ) {

                const char *arg = line_sections.items[i].string;

                if (skip_prefix(arg, "symref-target:", &arg))

                        ref->symref = xstrdup(arg);

440

                if (skip_prefix(arg, "peeled:", &arg)) {

442 struct object_id peeled_oid;

443 char *peeled_name;

444 struct ref *peeled;

                        if (parse_oid_hex_algop(arg, &peeled_oid, &end,

446 reader->hash_algo) || *end) {

447 ret = 0;

448 goto out;

449 }

450

                        peeled_name = xstrfmt("%s^{}", ref->name);

452 peeled = alloc_ref(peeled_name);

453

                        memcpy(peeled->old_oid.hash, peeled_oid.hash,

455 reader->hash_algo->rawsz);

456 **list = peeled;

457 *list = &peeled->next;

458

459 free(peeled_name);

460 }

461 }

462

463 out:

        string_list_clear(&line_sections, 0);

465 return ret;

466 }

467

void check_stateless_delimiter(int stateless_rpc,

469 struct packet_reader *reader,

470 const char *error)

471 {

472 if (!stateless_rpc)

473 return; /* not in stateless mode, no delimiter expected */

        if (packet_reader_read(reader) != PACKET_READ_RESPONSE_END)

                die("%s", error);

476 }

477

static void send_capabilities(int fd_out, struct packet_reader *reader)

479 {

480 const char *hash_name;

481

        if (server_supports_v2("agent"))

                packet_write_fmt(fd_out, "agent=%s", git_user_agent_sanitized());

484

        if (server_feature_v2("object-format", &hash_name)) {

                int hash_algo = hash_algo_by_name(hash_name);

487 if (hash_algo == GIT_HASH_UNKNOWN)

                        die(_("unknown object format '%s' specified by server"), hash_name);

489 reader->hash_algo = &hash_algos[hash_algo];

                packet_write_fmt(fd_out, "object-format=%s", reader->hash_algo->name);

491 } else {

492 reader->hash_algo = &hash_algos[GIT_HASH_SHA1];

493 }

494 }

495

struct ref **get_remote_refs(int fd_out, struct packet_reader *reader,

                             struct ref **list, int for_push,

498 struct transport_ls_refs_options *transport_options,

499 const struct string_list *server_options,

500 int stateless_rpc)

501 {

502 int i;

503 struct strvec *ref_prefixes = transport_options ?

504 &transport_options->ref_prefixes : NULL;

505 const char **unborn_head_target = transport_options ?

506 &transport_options->unborn_head_target : NULL;

507 *list = NULL;

508

509 ensure_server_supports_v2("ls-refs");

        packet_write_fmt(fd_out, "command=ls-refs\n");

511

512 /* Send capabilities */

513 send_capabilities(fd_out, reader);

514

        if (server_options && server_options->nr) {

516 ensure_server_supports_v2("server-option");

                for (i = 0; i < server_options->nr; i  )

                        packet_write_fmt(fd_out, "server-option=%s",

519 server_options->items[i].string);

520 }

521

522 packet_delim(fd_out);

523 /* When pushing we don't want to request the peeled tags */

524 if (!for_push)

                packet_write_fmt(fd_out, "peel\n");

        packet_write_fmt(fd_out, "symrefs\n");

        if (server_supports_feature("ls-refs", "unborn", 0))

                packet_write_fmt(fd_out, "unborn\n");

        for (i = 0; ref_prefixes && i < ref_prefixes->nr; i  ) {

                packet_write_fmt(fd_out, "ref-prefix %s\n",

531 ref_prefixes->v[i]);

532 }

533 packet_flush(fd_out);

534

535 /* Process response from server */

        while (packet_reader_read(reader) == PACKET_READ_NORMAL) {

                if (!process_ref_v2(reader, &list, unborn_head_target))

                        die(_("invalid ls-refs response: %s"), reader->line);

539 }

540

        if (reader->status != PACKET_READ_FLUSH)

                die(_("expected flush after ref listing"));

543

544 check_stateless_delimiter(stateless_rpc, reader,

545 _("expected response end packet after ref listing"));

546

547 return list;

548 }

549

const char *parse_feature_value(const char *feature_list, const char *feature, int *lenp, int *offset)

551 {

552 int len;

553

554 if (!feature_list)

555 return NULL;

556

557 len = strlen(feature);

558 if (offset)

559 feature_list = *offset;

560 while (*feature_list) {

                const char *found = strstr(feature_list, feature);

562 if (!found)

563 return NULL;

                if (feature_list == found || isspace(found[-1])) {

                        const char *value = found   len;

566 /* feature with no value (e.g., "thin-pack") */

                        if (!*value || isspace(*value)) {

568 if (lenp)

569 *lenp = 0;

570 if (offset)

                                        *offset = found   len - feature_list;

572 return value;

573 }

574 /* feature with a value (e.g., "agent=git/1.2.3") */

                        else if (*value == '=') {

576 int end;

577

578 value ;

                                end = strcspn(value, " \t\n");

580 if (lenp)

581 *lenp = end;

582 if (offset)

                                        *offset = value   end - feature_list;

584 return value;

585 }

586 /*

587 * otherwise we matched a substring of another feature;

588 * keep looking

589 */

590 }

591 feature_list = found 1;

592 }

593 return NULL;

863 }

595

int server_supports_hash(const char *desired, int *feature_supported)

597 {

598 int offset = 0;

599 int len;

600 const char *hash;

601

        hash = next_server_feature_value("object-format", &len, &offset);

603 if (feature_supported)

604 *feature_supported = !!hash;

605 if (!hash) {

606 hash = hash_algos[GIT_HASH_SHA1].name;

607 len = strlen(hash);

608 }

609 while (hash) {

                if (!xstrncmpz(desired, hash, len))

611 return 1;

612

                hash = next_server_feature_value("object-format", &len, &offset);

614 }

615 return 0;

616 }

617

int parse_feature_request(const char *feature_list, const char *feature)

619 {

        return !!parse_feature_value(feature_list, feature, NULL, NULL);

621 }

622

static const char *next_server_feature_value(const char *feature, int *len, int *offset)

624 {

        return parse_feature_value(server_capabilities_v1, feature, len, offset);

626 }

627

const char *server_feature_value(const char *feature, int *len)

629 {

        return parse_feature_value(server_capabilities_v1, feature, len, NULL);

631 }

632

int server_supports(const char *feature)

634 {

        return !!server_feature_value(feature, NULL);

636 }

637

638 enum protocol {

639 PROTO_LOCAL = 1,

640 PROTO_FILE,

641 PROTO_SSH,

642 PROTO_GIT

643 };

644

int url_is_local_not_ssh(const char *url)

646 {

        const char *colon = strchr(url, ':');

        const char *slash = strchr(url, '/');

        return !colon || (slash && slash < colon) ||

                (has_dos_drive_prefix(url) && is_valid_path(url));

651 }

652

static const char *prot_name(enum protocol protocol)

654 {

655 switch (protocol) {

656 case PROTO_LOCAL:

657 case PROTO_FILE:

658 return "file";

659 case PROTO_SSH:

660 return "ssh";

661 case PROTO_GIT:

662 return "git";

663 default:

664 return "unknown protocol";

665 }

666 }

667

static enum protocol get_protocol(const char *name)

669 {

        if (!strcmp(name, "ssh"))

671 return PROTO_SSH;

        if (!strcmp(name, "git"))

673 return PROTO_GIT;

        if (!strcmp(name, "git ssh")) /* deprecated - do not use */

675 return PROTO_SSH;

        if (!strcmp(name, "ssh git")) /* deprecated - do not use */

677 return PROTO_SSH;

        if (!strcmp(name, "file"))

679 return PROTO_FILE;

        die(_("protocol '%s' is not supported"), name);

681 }

682

static char *host_end(char **hoststart, int removebrackets)

684 {

685 char *host = *hoststart;

686 char *end;

        char *start = strstr(host, "@[");

688 if (start)

689 start ; /* Jump over '@' */

690 else

691 start = host;

        if (start[0] == '[') {

                end = strchr(start   1, ']');

694 if (end) {

695 if (removebrackets) {

696 *end = 0;

                                memmove(start, start   1, end - start);

698 end ;

699 }

700 } else

701 end = host;

702 } else

703 end = host;

704 return end;

705 }

706

707 #define STR_(s) # s

708 #define STR(s) STR_(s)

709

static void get_host_and_port(char **host, const char **port)

711 {

712 char *colon, *end;

        end = host_end(host, 1);

        colon = strchr(end, ':');

715 if (colon) {

                long portnr = strtol(colon   1, &end, 10);

                if (end != colon   1 && *end == '\0' && 0 <= portnr && portnr < 65536) {

718 *colon = 0;

                        *port = colon   1;

                } else if (!colon[1]) {

721 *colon = 0;

722 }

723 }

724 }

725

static void enable_keepalive(int sockfd)

727 {

728 int ka = 1;

729

        if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &ka, sizeof(ka)) < 0)

                error_errno(_("unable to set SO_KEEPALIVE on socket"));

732 }

733

734 #ifndef NO_IPV6

735

static const char *ai_name(const struct addrinfo *ai)

737 {

738 static char addr[NI_MAXHOST];

        if (getnameinfo(ai->ai_addr, ai->ai_addrlen, addr, sizeof(addr), NULL, 0,

740 NI_NUMERICHOST) != 0)

                xsnprintf(addr, sizeof(addr), "(unknown)");

742

743 return addr;

744 }

745

746 /*

747 * Returns a connected socket() fd, or else die()s.

748 */

static int git_tcp_connect_sock(char *host, int flags)

750 {

751 struct strbuf error_message = STRBUF_INIT;

752 int sockfd = -1;

        const char *port = STR(DEFAULT_GIT_PORT);

754 struct addrinfo hints, *ai0, *ai;

755 int gai;

756 int cnt = 0;

757

758 get_host_and_port(&host, &port);

759 if (!*port)

760 port = "<none>";

761

        memset(&hints, 0, sizeof(hints));

763 if (flags & CONNECT_IPV4)

764 hints.ai_family = AF_INET;

765 else if (flags & CONNECT_IPV6)

766 hints.ai_family = AF_INET6;

767 hints.ai_socktype = SOCK_STREAM;

768 hints.ai_protocol = IPPROTO_TCP;

769

770 if (flags & CONNECT_VERBOSE)

                fprintf(stderr, _("Looking up %s ... "), host);

772

        gai = getaddrinfo(host, port, &hints, &ai);

774 if (gai)

                die(_("unable to look up %s (port %s) (%s)"), host, port, gai_strerror(gai));

776

777 if (flags & CONNECT_VERBOSE)

778 /* TRANSLATORS: this is the end of "Looking up %s ... " */

                fprintf(stderr, _("done.\nConnecting to %s (port %s) ... "), host, port);

780

        for (ai0 = ai; ai; ai = ai->ai_next, cnt  ) {

                sockfd = socket(ai->ai_family,

783 ai->ai_socktype, ai->ai_protocol);

                if ((sockfd < 0) ||

                    (connect(sockfd, ai->ai_addr, ai->ai_addrlen) < 0)) {

                        strbuf_addf(&error_message, "%s[%d: %s]: errno=%s\n",

                                    host, cnt, ai_name(ai), strerror(errno));

                        if (0 <= sockfd)

789 close(sockfd);

790 sockfd = -1;

791 continue;

792 }

793 if (flags & CONNECT_VERBOSE)

                        fprintf(stderr, "%s ", ai_name(ai));

795 break;

796 }

797

798 freeaddrinfo(ai0);

799

        if (sockfd < 0)

                die(_("unable to connect to %s:\n%s"), host, error_message.buf);

802

803 enable_keepalive(sockfd);

804

805 if (flags & CONNECT_VERBOSE)

806 /* TRANSLATORS: this is the end of "Connecting to %s (port %s) ... " */

                fprintf_ln(stderr, _("done."));

808

809 strbuf_release(&error_message);

810

811 return sockfd;

812 }

813

814 #else /* NO_IPV6 */

815

816 /*

817 * Returns a connected socket() fd, or else die()s.

818 */

static int git_tcp_connect_sock(char *host, int flags)

820 {

821 struct strbuf error_message = STRBUF_INIT;

822 int sockfd = -1;

        const char *port = STR(DEFAULT_GIT_PORT);

824 char *ep;

825 struct hostent *he;

826 struct sockaddr_in sa;

827 char **ap;

828 unsigned int nport;

829 int cnt;

830

831 get_host_and_port(&host, &port);

832

833 if (flags & CONNECT_VERBOSE)

                fprintf(stderr, _("Looking up %s ... "), host);

835

836 he = gethostbyname(host);

837 if (!he)

                die(_("unable to look up %s (%s)"), host, hstrerror(h_errno));

        nport = strtoul(port, &ep, 10);

        if ( ep == port || *ep ) {

841 /* Not numeric */

                struct servent *se = getservbyname(port,"tcp");

843 if ( !se )

                        die(_("unknown port %s"), port);

845 nport = se->s_port;

846 }

847

848 if (flags & CONNECT_VERBOSE)

849 /* TRANSLATORS: this is the end of "Looking up %s ... " */

                fprintf(stderr, _("done.\nConnecting to %s (port %s) ... "), host, port);

851

        for (cnt = 0, ap = he->h_addr_list; *ap; ap  , cnt  ) {

                memset(&sa, 0, sizeof sa);

854 sa.sin_family = he->h_addrtype;

                sa.sin_port = htons(nport);

                memcpy(&sa.sin_addr, *ap, he->h_length);

857

                sockfd = socket(he->h_addrtype, SOCK_STREAM, 0);

                if ((sockfd < 0) ||

                    connect(sockfd, (struct sockaddr *)&sa, sizeof sa) < 0) {

                        strbuf_addf(&error_message, "%s[%d: %s]: errno=%s\n",

862 host,

863 cnt,

                                inet_ntoa(*(struct in_addr *)&sa.sin_addr),

865 strerror(errno));

                        if (0 <= sockfd)

867 close(sockfd);

868 sockfd = -1;

869 continue;

870 }

871 if (flags & CONNECT_VERBOSE)

                        fprintf(stderr, "%s ",

                                inet_ntoa(*(struct in_addr *)&sa.sin_addr));

874 break;

875 }

876

        if (sockfd < 0)

                die(_("unable to connect to %s:\n%s"), host, error_message.buf);

879

880 enable_keepalive(sockfd);

881

882 if (flags & CONNECT_VERBOSE)

883 /* TRANSLATORS: this is the end of "Connecting to %s (port %s) ... " */

                fprintf_ln(stderr, _("done."));

885

886 return sockfd;

887 }

888

889 #endif /* NO_IPV6 */

890

891

892 /*

893 * Dummy child_process returned by git_connect() if the transport protocol

894 * does not need fork(2).

895 */

896 static struct child_process no_fork = CHILD_PROCESS_INIT;

897

int git_connection_is_socket(struct child_process *conn)

899 {

900 return conn == &no_fork;

901 }

902

static struct child_process *git_tcp_connect(int fd[2], char *host, int flags)

904 {

        int sockfd = git_tcp_connect_sock(host, flags);

906

907 fd[0] = sockfd;

        fd[1] = dup(sockfd);

910 return &no_fork;

914 static char *git_proxy_command;

915

static int git_proxy_command_options(const char *var, const char *value,

917 void *cb)

918 {

        if (!strcmp(var, "core.gitproxy")) {

920 const char *for_pos;

921 int matchlen = -1;

922 int hostlen;

923 const char *rhost_name = cb;

                int rhost_len = strlen(rhost_name);

925

926 if (git_proxy_command)

927 return 0;

928 if (!value)

929 return config_error_nonbool(var);

930 /* [core]

931 * ;# matches www.kernel.org as well

932 * gitproxy = netcatter-1 for kernel.org

933 * gitproxy = netcatter-2 for sample.xz

934 * gitproxy = netcatter-default

935 */

                for_pos = strstr(value, " for ");

937 if (!for_pos)

938 /* matches everybody */

939 matchlen = strlen(value);

940 else {

                        hostlen = strlen(for_pos   5);

942 if (rhost_len < hostlen)

943 matchlen = -1;

                        else if (!strncmp(for_pos   5,

945 rhost_name rhost_len - hostlen,

946 hostlen) &&

947 ((rhost_len == hostlen) ||

                                  rhost_name[rhost_len - hostlen -1] == '.'))

949 matchlen = for_pos - value;

950 else

951 matchlen = -1;

952 }

                if (0 <= matchlen) {

954 /* core.gitproxy = none for kernel.org */

                        if (matchlen == 4 &&

                            !memcmp(value, "none", 4))

957 matchlen = 0;

                        git_proxy_command = xmemdupz(value, matchlen);

959 }

960 return 0;

961 }

962

        return git_default_config(var, value, cb);

964 }

965

static int git_use_proxy(const char *host)

967 {

        git_proxy_command = getenv("GIT_PROXY_COMMAND");

        git_config(git_proxy_command_options, (void*)host);

970 return (git_proxy_command && *git_proxy_command);

971 }

972

static struct child_process *git_proxy_connect(int fd[2], char *host)

974 {

        const char *port = STR(DEFAULT_GIT_PORT);

976 struct child_process *proxy;

977

978 get_host_and_port(&host, &port);

979

        if (looks_like_command_line_option(host))

                die(_("strange hostname '%s' blocked"), host);

        if (looks_like_command_line_option(port))

                die(_("strange port '%s' blocked"), port);

984

        proxy = xmalloc(sizeof(*proxy));

986 child_process_init(proxy);

        strvec_push(&proxy->args, git_proxy_command);

        strvec_push(&proxy->args, host);

        strvec_push(&proxy->args, port);

990 proxy->in = -1;

991 proxy->out = -1;

        if (start_command(proxy))

                die(_("cannot start proxy %s"), git_proxy_command);

        fd[0] = proxy->out; /* read from proxy stdout */

        fd[1] = proxy->in;  /* write to proxy stdin */

996 return proxy;

997 }

998

static char *get_port(char *host)

1000 {

1001 char *end;

        char *p = strchr(host, ':');

1003

1004 if (p) {

                long port = strtol(p   1, &end, 10);

                if (end != p   1 && *end == '\0' && 0 <= port && port < 65536) {

1007 *p = '\0';

1008 return p 1;

1009 }

1010 }

1011

1012 return NULL;

1013 }

1014

1015 /*

1016 * Extract protocol and relevant parts from the specified connection URL.

1017 * The caller must free() the returned strings.

1018 */

static enum protocol parse_connect_url(const char *url_orig, char **ret_host,

1020 char **ret_path)

1021 {

1022 char *url;

1023 char *host, *path;

1024 char *end;

1025 int separator = '/';

1026 enum protocol protocol = PROTO_LOCAL;

1027

        if (is_url(url_orig))

1029 url = url_decode(url_orig);

1030 else

1031 url = xstrdup(url_orig);

1032

        host = strstr(url, "://");

1034 if (host) {

1035 *host = '\0';

1036 protocol = get_protocol(url);

1037 host = 3;

1038 } else {

1039 host = url;

                if (!url_is_local_not_ssh(url)) {

1041 protocol = PROTO_SSH;

1042 separator = ':';

1043 }

1044 }

1045

1046 /*

1047 * Don't do destructive transforms as protocol code does

1048 * '[]' unwrapping in get_host_and_port()

1049 */

        end = host_end(&host, 0);

1051

1052 if (protocol == PROTO_LOCAL)

1053 path = end;

        else if (protocol == PROTO_FILE && *host != '/' &&

1055 !has_dos_drive_prefix(host) &&

                 offset_1st_component(host - 2) > 1)

                path = host - 2; /* include the leading "//" */

        else if (protocol == PROTO_FILE && has_dos_drive_prefix(end))

1059 path = end; /* "file://$(pwd)" may be "file://C:/projects/repo" */

1060 else

                path = strchr(end, separator);

1062

1063 if (!path || !*path)

                die(_("no path specified; see 'git help pull' for valid url syntax"));

1065

1066 /*

1067 * null-terminate hostname and point path to ~ for URL's like this:

1068 * ssh://host.xz/~user/repo

1069 */

1070

1071 end = path; /* Need to \0 terminate host here */

        if (separator == ':')

1073 path ; /* path starts after ':' */

        if (protocol == PROTO_GIT || protocol == PROTO_SSH) {

                if (path[1] == '~')

1076 path ;

1077 }

1078

1079 path = xstrdup(path);

1080 *end = '\0';

1081

        *ret_host = xstrdup(host);

1083 *ret_path = path;

1084 free(url);

1085 return protocol;

1086 }

1087

static const char *get_ssh_command(void)

1089 {

1090 const char *ssh;

1091

        if ((ssh = getenv("GIT_SSH_COMMAND")))

1093 return ssh;

1094

        if (!git_config_get_string_tmp("core.sshcommand", &ssh))

1096 return ssh;

1097

1098 return NULL;

1099 }

1100

1101 enum ssh_variant {

1102 VARIANT_AUTO,

1103 VARIANT_SIMPLE,

1104 VARIANT_SSH,

1105 VARIANT_PLINK,

1106 VARIANT_PUTTY,

1107 VARIANT_TORTOISEPLINK,

1108 };

1109

static void override_ssh_variant(enum ssh_variant *ssh_variant)

1111 {

        const char *variant = getenv("GIT_SSH_VARIANT");

1113

        if (!variant && git_config_get_string_tmp("ssh.variant", &variant))

1115 return;

1116

        if (!strcmp(variant, "auto"))

1118 *ssh_variant = VARIANT_AUTO;

        else if (!strcmp(variant, "plink"))

1120 *ssh_variant = VARIANT_PLINK;

        else if (!strcmp(variant, "putty"))

1122 *ssh_variant = VARIANT_PUTTY;

        else if (!strcmp(variant, "tortoiseplink"))

1124 *ssh_variant = VARIANT_TORTOISEPLINK;

        else if (!strcmp(variant, "simple"))

1126 *ssh_variant = VARIANT_SIMPLE;

1127 else

1128 *ssh_variant = VARIANT_SSH;

1129 }

1130

static enum ssh_variant determine_ssh_variant(const char *ssh_command,

1132 int is_cmdline)

1133 {

1134 enum ssh_variant ssh_variant = VARIANT_AUTO;

1135 const char *variant;

1136 char *p = NULL;

1137

1138 override_ssh_variant(&ssh_variant);

1139

1140 if (ssh_variant != VARIANT_AUTO)

1141 return ssh_variant;

1142

1143 if (!is_cmdline) {

1144 p = xstrdup(ssh_command);

1145 variant = basename(p);

1146 } else {

1147 const char **ssh_argv;

1148

1149 p = xstrdup(ssh_command);

                if (split_cmdline(p, &ssh_argv) > 0) {

                        variant = basename((char *)ssh_argv[0]);

1152 /*

1153 * At this point, variant points into the buffer

1154 * referenced by p, hence we do not need ssh_argv

1155 * any longer.

1156 */

1157 free(ssh_argv);

1158 } else {

1159 free(p);

1160 return ssh_variant;

1161 }

1162 }

1163

        if (!strcasecmp(variant, "ssh") ||

            !strcasecmp(variant, "ssh.exe"))

1166 ssh_variant = VARIANT_SSH;

        else if (!strcasecmp(variant, "plink") ||

                 !strcasecmp(variant, "plink.exe"))

1169 ssh_variant = VARIANT_PLINK;

        else if (!strcasecmp(variant, "tortoiseplink") ||

                 !strcasecmp(variant, "tortoiseplink.exe"))

1172 ssh_variant = VARIANT_TORTOISEPLINK;

1173

1174 free(p);

1175 return ssh_variant;

1176 }

1177

1178 /*

1179 * Open a connection using Git's native protocol.

1180 *

1181 * The caller is responsible for freeing hostandport, but this function may

1182 * modify it (for example, to truncate it to remove the port part).

1183 */

static struct child_process *git_connect_git(int fd[2], char *hostandport,

                                             const char *path, const char *prog,

1186 enum protocol_version version,

1187 int flags)

1188 {

1189 struct child_process *conn;

1190 struct strbuf request = STRBUF_INIT;

1191 /*

1192 * Set up virtual host information based on where we will

1193 * connect, unless the user has overridden us in

1194 * the environment.

1195 */

        char *target_host = getenv("GIT_OVERRIDE_VIRTUAL_HOST");

1197 if (target_host)

1198 target_host = xstrdup(target_host);

1199 else

1200 target_host = xstrdup(hostandport);

1201

1202 transport_check_allowed("git");

        if (strchr(target_host, '\n') || strchr(path, '\n'))

                die(_("newline is forbidden in git:// hosts and repo paths"));

1205

1206 /*

1207 * These underlying connection commands die() if they

1208 * cannot connect.

1209 */

        if (git_use_proxy(hostandport))

                conn = git_proxy_connect(fd, hostandport);

1212 else

                conn = git_tcp_connect(fd, hostandport, flags);

1214 /*

1215 * Separate original protocol components prog and path

1216 * from extended host header with a NUL byte.

1217 *

1218 * Note: Do not add any other headers here! Doing so

1219 * will cause older git-daemon servers to crash.

1220 */

1221 strbuf_addf(&request,

1222 "%s %s%chost=%s%c",

1223 prog, path, 0,

1224 target_host, 0);

1225

1226 /* If using a new version put that stuff here after a second null byte */

        if (version > 0) {

                strbuf_addch(&request, '\0');

                strbuf_addf(&request, "version=%d%c",

1230 version, '\0');

1231 }

1232

        packet_write(fd[1], request.buf, request.len);

1234

1235 free(target_host);

1236 strbuf_release(&request);

1237 return conn;

1238 }

1239

1240 /*

1241 * Append the appropriate environment variables to `env` and options to

1242 * `args` for running ssh in Git's SSH-tunneled transport.

1243 */

static void push_ssh_options(struct strvec *args, struct strvec *env,

                             enum ssh_variant variant, const char *port,

1246 enum protocol_version version, int flags)

1247 {

1248 if (variant == VARIANT_SSH &&

1249 version > 0) {

                strvec_push(args, "-o");

                strvec_push(args, "SendEnv=" GIT_PROTOCOL_ENVIRONMENT);

                strvec_pushf(env, GIT_PROTOCOL_ENVIRONMENT "=version=%d",

1253 version);

1254 }

1255

1256 if (flags & CONNECT_IPV4) {

1257 switch (variant) {

1258 case VARIANT_AUTO:

1259 BUG("VARIANT_AUTO passed to push_ssh_options");

1260 case VARIANT_SIMPLE:

                        die(_("ssh variant 'simple' does not support -4"));

1262 case VARIANT_SSH:

1263 case VARIANT_PLINK:

1264 case VARIANT_PUTTY:

1265 case VARIANT_TORTOISEPLINK:

                        strvec_push(args, "-4");

1267 }

        } else if (flags & CONNECT_IPV6) {

1269 switch (variant) {

1270 case VARIANT_AUTO:

1271 BUG("VARIANT_AUTO passed to push_ssh_options");

1272 case VARIANT_SIMPLE:

                        die(_("ssh variant 'simple' does not support -6"));

1274 case VARIANT_SSH:

1275 case VARIANT_PLINK:

1276 case VARIANT_PUTTY:

1277 case VARIANT_TORTOISEPLINK:

                        strvec_push(args, "-6");

1279 }

1280 }

1281

1282 if (variant == VARIANT_TORTOISEPLINK)

                strvec_push(args, "-batch");

1284

1285 if (port) {

1286 switch (variant) {

1287 case VARIANT_AUTO:

1288 BUG("VARIANT_AUTO passed to push_ssh_options");

1289 case VARIANT_SIMPLE:

                        die(_("ssh variant 'simple' does not support setting port"));

1291 case VARIANT_SSH:

                        strvec_push(args, "-p");

1293 break;

1294 case VARIANT_PLINK:

1295 case VARIANT_PUTTY:

1296 case VARIANT_TORTOISEPLINK:

                        strvec_push(args, "-P");

1298 }

1299

1300 strvec_push(args, port);

1301 }

1302 }

1303

1304 /* Prepare a child_process for use by Git's SSH-tunneled transport. */

static void fill_ssh_args(struct child_process *conn, const char *ssh_host,

                          const char *port, enum protocol_version version,

1307 int flags)

1308 {

1309 const char *ssh;

1310 enum ssh_variant variant;

1311

        if (looks_like_command_line_option(ssh_host))

                die(_("strange hostname '%s' blocked"), ssh_host);

1314

1315 ssh = get_ssh_command();

1316 if (ssh) {

                variant = determine_ssh_variant(ssh, 1);

1318 } else {

1319 /*

1320 * GIT_SSH is the no-shell version of

1321 * GIT_SSH_COMMAND (and must remain so for

1322 * historical compatibility).

1323 */

1324 conn->use_shell = 0;

1325

                ssh = getenv("GIT_SSH");

1327 if (!ssh)

1328 ssh = "ssh";

                variant = determine_ssh_variant(ssh, 0);

1330 }

1331

1332 if (variant == VARIANT_AUTO) {

1333 struct child_process detect = CHILD_PROCESS_INIT;

1334

1335 detect.use_shell = conn->use_shell;

                detect.no_stdin = detect.no_stdout = detect.no_stderr = 1;

1337

                strvec_push(&detect.args, ssh);

                strvec_push(&detect.args, "-G");

                push_ssh_options(&detect.args, &detect.env,

1341 VARIANT_SSH, port, version, flags);

                strvec_push(&detect.args, ssh_host);

1343

                variant = run_command(&detect) ? VARIANT_SIMPLE : VARIANT_SSH;

1345 }

1346

        strvec_push(&conn->args, ssh);

        push_ssh_options(&conn->args, &conn->env, variant, port, version,

1349 flags);

        strvec_push(&conn->args, ssh_host);

1351 }

1352

1353 /*

1354 * This returns the dummy child_process `no_fork` if the transport protocol

1355 * does not need fork(2), or a struct child_process object if it does. Once

1356 * done, finish the connection with finish_connect() with the value returned

1357 * from this function (it is safe to call finish_connect() with NULL to

1358 * support the former case).

1359 *

1360 * If it returns, the connect is successful; it just dies on errors (this

1361 * will hopefully be changed in a libification effort, to return NULL when

1362 * the connection failed).

1363 */

struct child_process *git_connect(int fd[2], const char *url,

                                  const char *prog, int flags)

1366 {

1367 char *hostandport, *path;

1368 struct child_process *conn;

1369 enum protocol protocol;

1370 enum protocol_version version = get_protocol_version_config();

1371

1372 /*

1373 * NEEDSWORK: If we are trying to use protocol v2 and we are planning

1374 * to perform a push, then fallback to v0 since the client doesn't know

1375 * how to push yet using v2.

1376 */

        if (version == protocol_v2 && !strcmp("git-receive-pack", prog))

1378 version = protocol_v0;

1379

1380 /* Without this we cannot rely on waitpid() to tell

1381 * what happened to our children.

1382 */

1383 signal(SIGCHLD, SIG_DFL);

1384

        protocol = parse_connect_url(url, &hostandport, &path);

        if ((flags & CONNECT_DIAG_URL) && (protocol != PROTO_SSH)) {

                printf("Diag: url=%s\n", url ? url : "NULL");

                printf("Diag: protocol=%s\n", prot_name(protocol));

                printf("Diag: hostandport=%s\n", hostandport ? hostandport : "NULL");

                printf("Diag: path=%s\n", path ? path : "NULL");

1391 conn = NULL;

        } else if (protocol == PROTO_GIT) {

                conn = git_connect_git(fd, hostandport, path, prog, version, flags);

1394 conn->trace2_child_class = "transport/git";

1395 } else {

1396 struct strbuf cmd = STRBUF_INIT;

                const char *const *var;

1398

                conn = xmalloc(sizeof(*conn));

1400 child_process_init(conn);

1401

                if (looks_like_command_line_option(path))

                        die(_("strange pathname '%s' blocked"), path);

1404

1405 strbuf_addstr(&cmd, prog);

                strbuf_addch(&cmd, ' ');

1407 sq_quote_buf(&cmd, path);

1408

1409 /* remove repo-local variables from the environment */

                for (var = local_repo_env; *var; var  )

                        strvec_push(&conn->env, *var);

1412

1413 conn->use_shell = 1;

                conn->in = conn->out = -1;

1415 if (protocol == PROTO_SSH) {

1416 char *ssh_host = hostandport;

1417 const char *port = NULL;

1418 transport_check_allowed("ssh");

1419 get_host_and_port(&ssh_host, &port);

1420

1421 if (!port)

1422 port = get_port(ssh_host);

1423

1424 if (flags & CONNECT_DIAG_URL) {

                                printf("Diag: url=%s\n", url ? url : "NULL");

                                printf("Diag: protocol=%s\n", prot_name(protocol));

                                printf("Diag: userandhost=%s\n", ssh_host ? ssh_host : "NULL");

                                printf("Diag: port=%s\n", port ? port : "NONE");

                                printf("Diag: path=%s\n", path ? path : "NULL");

1430

1431 free(hostandport);

1432 free(path);

1433 free(conn);

1434 strbuf_release(&cmd);

1435 return NULL;

1436 }

1437 conn->trace2_child_class = "transport/ssh";

                        fill_ssh_args(conn, ssh_host, port, version, flags);

1439 } else {

1440 transport_check_allowed("file");

1441 conn->trace2_child_class = "transport/file";

                        if (version > 0) {

1443 strvec_pushf(&conn->env,

1444 GIT_PROTOCOL_ENVIRONMENT "=version=%d",

1445 version);

1446 }

1447 }

                strvec_push(&conn->args, cmd.buf);

1449

                if (start_command(conn))

                        die(_("unable to fork"));

1452

                fd[0] = conn->out; /* read from child's stdout */

                fd[1] = conn->in;  /* write to child's stdin */

1455 strbuf_release(&cmd);

1456 }

1457 free(hostandport);

1458 free(path);

1459 return conn;

1460 }

1461

int finish_connect(struct child_process *conn)

1463 {

1464 int code;

        if (!conn || git_connection_is_socket(conn))

1466 return 0;

1467

1468 code = finish_command(conn);

1469 free(conn);

1470 return code;

1471 }