local.c 15.4 KB
Newer Older
Vicent Marti committed
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
Vicent Marti committed
3 4 5 6
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */
7 8 9 10
#include "common.h"
#include "git2/types.h"
#include "git2/net.h"
#include "git2/repository.h"
11 12
#include "git2/object.h"
#include "git2/tag.h"
13
#include "git2/transport.h"
14 15 16 17 18
#include "git2/revwalk.h"
#include "git2/odb_backend.h"
#include "git2/pack.h"
#include "git2/commit.h"
#include "git2/revparse.h"
19
#include "git2/push.h"
20 21
#include "pack-objects.h"
#include "refs.h"
22
#include "posix.h"
23 24
#include "path.h"
#include "buffer.h"
25 26
#include "repository.h"
#include "odb.h"
27 28
#include "push.h"
#include "remote.h"
29

30
typedef struct {
31
	git_transport parent;
32
	git_remote *owner;
33 34 35 36
	char *url;
	int direction;
	int flags;
	git_atomic cancelled;
37
	git_repository *repo;
38
	git_vector refs;
39 40
	unsigned connected : 1,
		have_refs : 1;
41
} transport_local;
42

43
static int add_ref(transport_local *t, const char *name)
44 45
{
	const char peeled[] = "^{}";
46
	git_oid head_oid;
47
	git_remote_head *head;
48 49
	git_object *obj = NULL, *target = NULL;
	git_buf buf = GIT_BUF_INIT;
50
	int error;
51

52
	error = git_reference_name_to_id(&head_oid, t->repo, name);
53
	if (error < 0) {
54
		if (!strcmp(name, GIT_HEAD_FILE) && error == GIT_ENOTFOUND) {
55 56
			/* This is actually okay.  Empty repos often have a HEAD that
			 * points to a nonexistent "refs/heads/master". */
57 58 59 60
			giterr_clear();
			return 0;
		}
		return error;
61 62
	}

63 64 65 66 67 68 69 70 71
	head = git__calloc(1, sizeof(git_remote_head));
	GITERR_CHECK_ALLOC(head);

	head->name = git__strdup(name);
	GITERR_CHECK_ALLOC(head->name);

	git_oid_cpy(&head->oid, &head_oid);

	if ((error = git_vector_insert(&t->refs, head)) < 0) {
72 73
		git__free(head->name);
		git__free(head);
74
		return error;
75
	}
76 77 78

	/* If it's not a tag, we don't need to try to peel it */
	if (git__prefixcmp(name, GIT_REFS_TAGS_DIR))
79
		return 0;
80

81 82
	if ((error = git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY)) < 0)
		return error;
83

84 85
	head = NULL;

86 87 88 89
	/* If it's not an annotated tag, or if we're mocking
	 * git-receive-pack, just get out */
	if (git_object_type(obj) != GIT_OBJ_TAG ||
		t->direction != GIT_DIRECTION_FETCH) {
90 91 92
		git_object_free(obj);
		return 0;
	}
93 94

	/* And if it's a tag, peel it, and add it to the list */
95
	head = git__calloc(1, sizeof(git_remote_head));
96
	GITERR_CHECK_ALLOC(head);
97

98 99 100
	if (git_buf_join(&buf, 0, name, peeled) < 0)
		return -1;
	head->name = git_buf_detach(&buf);
101

102 103
	if (!(error = git_tag_peel(&target, (git_tag *)obj))) {
		git_oid_cpy(&head->oid, git_object_id(target));
104

105 106 107 108 109
		if ((error = git_vector_insert(&t->refs, head)) < 0) {
			git__free(head->name);
			git__free(head);
		}
	}
110

111
	git_object_free(obj);
112
	git_object_free(target);
113 114

	return error;
115 116
}

117
static int store_refs(transport_local *t)
118
{
119 120
	size_t i;
	git_remote_head *head;
121
	git_strarray ref_names = {0};
122

123
	assert(t);
124

125
	if (git_reference_list(&ref_names, t->repo) < 0)
126
		goto on_error;
127

128 129 130 131 132 133 134 135 136
	/* Clear all heads we might have fetched in a previous connect */
	git_vector_foreach(&t->refs, i, head) {
		git__free(head->name);
		git__free(head);
	}

	/* Clear the vector so we can reuse it */
	git_vector_clear(&t->refs);

137
	/* Sort the references first */
138
	git__tsort((void **)ref_names.strings, ref_names.count, &git__strcmp_cb);
139

140 141
	/* Add HEAD iff direction is fetch */
	if (t->direction == GIT_DIRECTION_FETCH && add_ref(t, GIT_HEAD_FILE) < 0)
142
		goto on_error;
143

144
	for (i = 0; i < ref_names.count; ++i) {
145 146
		if (add_ref(t, ref_names.strings[i]) < 0)
			goto on_error;
147
	}
148

149
	t->have_refs = 1;
150
	git_strarray_free(&ref_names);
151 152 153
	return 0;

on_error:
154
	git_vector_free(&t->refs);
155
	git_strarray_free(&ref_names);
156
	return -1;
157
}
158

159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
static int path_from_url_or_path(git_buf *local_path_out, const char *url_or_path)
{
	int error;

	/* If url_or_path begins with file:// treat it as a URL */
	if (!git__prefixcmp(url_or_path, "file://")) {
		if ((error = git_path_fromurl(local_path_out, url_or_path)) < 0) {
			return error;
		}
	} else { /* We assume url_or_path is already a path */
		if ((error = git_buf_sets(local_path_out, url_or_path)) < 0) {
			return error;
		}
	}

	return 0;
}

177 178 179 180
/*
 * Try to open the url as a git directory. The direction doesn't
 * matter in this case because we're calulating the heads ourselves.
 */
181 182 183 184
static int local_connect(
	git_transport *transport,
	const char *url,
	git_cred_acquire_cb cred_acquire_cb,
185
	void *cred_acquire_payload,
186
	int direction, int flags)
187 188 189 190 191
{
	git_repository *repo;
	int error;
	transport_local *t = (transport_local *) transport;
	const char *path;
192 193
	git_buf buf = GIT_BUF_INIT;

194
	GIT_UNUSED(cred_acquire_cb);
195
	GIT_UNUSED(cred_acquire_payload);
196

197 198 199
	if (t->connected)
		return 0;

200 201 202 203
	t->url = git__strdup(url);
	GITERR_CHECK_ALLOC(t->url);
	t->direction = direction;
	t->flags = flags;
204

205 206 207 208
	/* 'url' may be a url or path; convert to a path */
	if ((error = path_from_url_or_path(&buf, url)) < 0) {
		git_buf_free(&buf);
		return error;
209
	}
210
	path = git_buf_cstr(&buf);
211 212

	error = git_repository_open(&repo, path);
213 214 215

	git_buf_free(&buf);

216 217
	if (error < 0)
		return -1;
218

219 220
	t->repo = repo;

221 222
	if (store_refs(t) < 0)
		return -1;
223

224 225 226 227 228
	t->connected = 1;

	return 0;
}

229
static int local_ls(const git_remote_head ***out, size_t *size, git_transport *transport)
230 231 232
{
	transport_local *t = (transport_local *)transport;

233 234
	if (!t->have_refs) {
		giterr_set(GITERR_NET, "The transport has not yet loaded the refs");
235 236 237
		return -1;
	}

238
	*out = (const git_remote_head **)t->refs.contents;
239
	*size = t->refs.length;
240

241
	return 0;
242 243
}

244 245 246
static int local_negotiate_fetch(
	git_transport *transport,
	git_repository *repo,
247 248
	const git_remote_head * const *refs,
	size_t count)
249
{
250 251 252 253
	transport_local *t = (transport_local*)transport;
	git_remote_head *rhead;
	unsigned int i;

254 255
	GIT_UNUSED(refs);
	GIT_UNUSED(count);
256

257 258 259 260 261 262 263 264 265
	/* Fill in the loids */
	git_vector_foreach(&t->refs, i, rhead) {
		git_object *obj;

		int error = git_revparse_single(&obj, repo, rhead->name);
		if (!error)
			git_oid_cpy(&rhead->loid, git_object_id(obj));
		else if (error != GIT_ENOTFOUND)
			return error;
266 267
		else
			giterr_clear();
nulltoken committed
268
		git_object_free(obj);
269 270 271 272 273
	}

	return 0;
}

274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
static int local_push_copy_object(
	git_odb *local_odb,
	git_odb *remote_odb,
	git_pobject *obj)
{
	int error = 0;
	git_odb_object *odb_obj = NULL;
	git_odb_stream *odb_stream;
	size_t odb_obj_size;
	git_otype odb_obj_type;
	git_oid remote_odb_obj_oid;

	/* Object already exists in the remote ODB; do nothing and return 0*/
	if (git_odb_exists(remote_odb, &obj->id))
		return 0;

	if ((error = git_odb_read(&odb_obj, local_odb, &obj->id)) < 0)
		return error;

	odb_obj_size = git_odb_object_size(odb_obj);
	odb_obj_type = git_odb_object_type(odb_obj);

	if ((error = git_odb_open_wstream(&odb_stream, remote_odb,
		odb_obj_size, odb_obj_type)) < 0)
		goto on_error;

300
	if (git_odb_stream_write(odb_stream, (char *)git_odb_object_data(odb_obj),
301
		odb_obj_size) < 0 ||
302
		git_odb_stream_finalize_write(&remote_odb_obj_oid, odb_stream) < 0) {
303
		error = -1;
304
	} else if (git_oid__cmp(&obj->id, &remote_odb_obj_oid) != 0) {
305 306 307 308 309 310
		giterr_set(GITERR_ODB, "Error when writing object to remote odb "
			"during local push operation. Remote odb object oid does not "
			"match local oid.");
		error = -1;
	}

311
	git_odb_stream_free(odb_stream);
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333

on_error:
	git_odb_object_free(odb_obj);
	return error;
}

static int local_push_update_remote_ref(
	git_repository *remote_repo,
	const char *lref,
	const char *rref,
	git_oid *loid,
	git_oid *roid)
{
	int error;
	git_reference *remote_ref = NULL;

	/* rref will be NULL if it is implicit in the pushspec (e.g. 'b1:') */
	rref = rref ? rref : lref;

	if (lref) {
		/* Create or update a ref */
		if ((error = git_reference_create(NULL, remote_repo, rref, loid,
334
				!git_oid_iszero(roid), NULL, NULL)) < 0)
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
			return error;
	} else {
		/* Delete a ref */
		if ((error = git_reference_lookup(&remote_ref, remote_repo, rref)) < 0) {
			if (error == GIT_ENOTFOUND)
				error = 0;
			return error;
		}

		if ((error = git_reference_delete(remote_ref)) < 0)
			return error;

		git_reference_free(remote_ref);
	}

	return 0;
}

static int local_push(
	git_transport *transport,
	git_push *push)
{
	transport_local *t = (transport_local *)transport;
	git_odb *remote_odb = NULL;
	git_odb *local_odb = NULL;
	git_repository *remote_repo = NULL;
	push_spec *spec;
	char *url = NULL;
363 364
	const char *path;
	git_buf buf = GIT_BUF_INIT;
365 366 367 368
	int error;
	unsigned int i;
	size_t j;

369 370 371 372
	/* 'push->remote->url' may be a url or path; convert to a path */
	if ((error = path_from_url_or_path(&buf, push->remote->url)) < 0) {
		git_buf_free(&buf);
		return error;
373
	}
374
	path = git_buf_cstr(&buf);
375 376 377 378 379 380

	error = git_repository_open(&remote_repo, path);

	git_buf_free(&buf);

	if (error < 0)
381 382
		return error;

nulltoken committed
383
	/* We don't currently support pushing locally to non-bare repos. Proper
384 385 386
	   non-bare repo push support would require checking configs to see if
	   we should override the default 'don't let this happen' behavior */
	if (!remote_repo->is_bare) {
387 388
		error = GIT_EBAREREPO;
		giterr_set(GITERR_INVALID, "Local push doesn't (yet) support pushing to non-bare repos.");
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
		goto on_error;
	}

	if ((error = git_repository_odb__weakptr(&remote_odb, remote_repo)) < 0 ||
		(error = git_repository_odb__weakptr(&local_odb, push->repo)) < 0)
		goto on_error;

	for (i = 0; i < push->pb->nr_objects; i++) {
		if ((error = local_push_copy_object(local_odb, remote_odb,
			&push->pb->object_list[i])) < 0)
			goto on_error;
	}

	push->unpack_ok = 1;

	git_vector_foreach(&push->specs, j, spec) {
		push_status *status;
		const git_error *last;
		char *ref = spec->rref ? spec->rref : spec->lref;

		status = git__calloc(sizeof(push_status), 1);
		if (!status)
			goto on_error;

		status->ref = git__strdup(ref);
		if (!status->ref) {
			git_push_status_free(status);
			goto on_error;
		}

		error = local_push_update_remote_ref(remote_repo, spec->lref, spec->rref,
			&spec->loid, &spec->roid);

		switch (error) {
			case GIT_OK:
				break;
			case GIT_EINVALIDSPEC:
				status->msg = git__strdup("funny refname");
				break;
			case GIT_ENOTFOUND:
				status->msg = git__strdup("Remote branch not found to delete");
				break;
			default:
				last = giterr_last();

				if (last && last->message)
					status->msg = git__strdup(last->message);
				else
					status->msg = git__strdup("Unspecified error encountered");
				break;
		}

		/* failed to allocate memory for a status message */
		if (error < 0 && !status->msg) {
			git_push_status_free(status);
			goto on_error;
		}

		/* failed to insert the ref update status */
		if ((error = git_vector_insert(&push->status, status)) < 0) {
			git_push_status_free(status);
			goto on_error;
		}
	}

	if (push->specs.length) {
		int flags = t->flags;
		url = git__strdup(t->url);

		if (!url || t->parent.close(&t->parent) < 0 ||
			t->parent.connect(&t->parent, url,
460
			push->remote->callbacks.credentials, NULL, GIT_DIRECTION_PUSH, flags))
461 462 463 464 465 466 467 468 469 470 471 472
			goto on_error;
	}

	error = 0;

on_error:
	git_repository_free(remote_repo);
	git__free(url);

	return error;
}

473 474
typedef struct foreach_data {
	git_transfer_progress *stats;
475
	git_transfer_progress_cb progress_cb;
476 477 478 479 480 481 482 483 484
	void *progress_payload;
	git_odb_writepack *writepack;
} foreach_data;

static int foreach_cb(void *buf, size_t len, void *payload)
{
	foreach_data *data = (foreach_data*)payload;

	data->stats->received_bytes += len;
485
	return data->writepack->append(data->writepack, buf, len, data->stats);
486 487 488 489 490 491
}

static int local_download_pack(
		git_transport *transport,
		git_repository *repo,
		git_transfer_progress *stats,
492
		git_transfer_progress_cb progress_cb,
493 494 495 496 497 498 499 500 501 502
		void *progress_payload)
{
	transport_local *t = (transport_local*)transport;
	git_revwalk *walk = NULL;
	git_remote_head *rhead;
	unsigned int i;
	int error = -1;
	git_oid oid;
	git_packbuilder *pack = NULL;
	git_odb_writepack *writepack = NULL;
503
	git_odb *odb = NULL;
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530

	if ((error = git_revwalk_new(&walk, t->repo)) < 0)
		goto cleanup;
	git_revwalk_sorting(walk, GIT_SORT_TIME);

	if ((error = git_packbuilder_new(&pack, t->repo)) < 0)
		goto cleanup;

	stats->total_objects = 0;
	stats->indexed_objects = 0;
	stats->received_objects = 0;
	stats->received_bytes = 0;

	git_vector_foreach(&t->refs, i, rhead) {
		git_object *obj;
		if ((error = git_object_lookup(&obj, t->repo, &rhead->oid, GIT_OBJ_ANY)) < 0)
			goto cleanup;

		if (git_object_type(obj) == GIT_OBJ_COMMIT) {
			/* Revwalker includes only wanted commits */
			error = git_revwalk_push(walk, &rhead->oid);
			if (!git_oid_iszero(&rhead->loid))
				error = git_revwalk_hide(walk, &rhead->loid);
		} else {
			/* Tag or some other wanted object. Add it on its own */
			error = git_packbuilder_insert(pack, &rhead->oid, rhead->name);
		}
Linquize committed
531
		git_object_free(obj);
532 533 534
	}

	/* Walk the objects, building a packfile */
535 536
	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
		goto cleanup;
537 538 539 540

	while ((error = git_revwalk_next(&oid, walk)) == 0) {
		git_commit *commit;

541 542 543
		/* Skip commits we already have */
		if (git_odb_exists(odb, &oid)) continue;

544
		if (!git_object_lookup((git_object**)&commit, t->repo, &oid, GIT_OBJ_COMMIT)) {
Vicent Marti committed
545
			const git_oid *tree_oid = git_commit_tree_id(commit);
546 547 548

			/* Add the commit and its tree */
			if ((error = git_packbuilder_insert(pack, &oid, NULL)) < 0 ||
549 550
				 (error = git_packbuilder_insert_tree(pack, tree_oid)) < 0) {
				git_commit_free(commit);
551
				goto cleanup;
552 553 554
			}

			git_commit_free(commit);
555 556 557
		}
	}

558
	if ((error = git_odb_write_pack(&writepack, odb, progress_cb, progress_payload)) != 0)
559
		goto cleanup;
560 561 562 563 564 565 566 567 568

	/* Write the data to the ODB */
	{
		foreach_data data = {0};
		data.stats = stats;
		data.progress_cb = progress_cb;
		data.progress_payload = progress_payload;
		data.writepack = writepack;

569
		if ((error = git_packbuilder_foreach(pack, foreach_cb, &data)) != 0)
570 571 572 573 574 575 576 577 578
			goto cleanup;
	}
	error = writepack->commit(writepack, stats);

cleanup:
	if (writepack) writepack->free(writepack);
	git_packbuilder_free(pack);
	git_revwalk_free(walk);
	return error;
579 580
}

581
static int local_is_connected(git_transport *transport)
582 583 584
{
	transport_local *t = (transport_local *)transport;

585
	return t->connected;
586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
}

static int local_read_flags(git_transport *transport, int *flags)
{
	transport_local *t = (transport_local *)transport;

	*flags = t->flags;

	return 0;
}

static void local_cancel(git_transport *transport)
{
	transport_local *t = (transport_local *)transport;

	git_atomic_set(&t->cancelled, 1);
}

604
static int local_close(git_transport *transport)
605
{
606 607
	transport_local *t = (transport_local *)transport;

608
	t->connected = 0;
609 610 611 612 613 614 615 616 617 618

	if (t->repo) {
		git_repository_free(t->repo);
		t->repo = NULL;
	}

	if (t->url) {
		git__free(t->url);
		t->url = NULL;
	}
619

620
	return 0;
621 622
}

623 624
static void local_free(git_transport *transport)
{
625
	transport_local *t = (transport_local *)transport;
626 627 628 629 630 631 632
	size_t i;
	git_remote_head *head;

	git_vector_foreach(&t->refs, i, head) {
		git__free(head->name);
		git__free(head);
	}
633

634 635
	git_vector_free(&t->refs);

636 637
	/* Close the transport, if it's still open. */
	local_close(transport);
638

639
	/* Free the transport */
640
	git__free(t);
641 642
}

643 644 645 646
/**************
 * Public API *
 **************/

647
int git_transport_local(git_transport **out, git_remote *owner, void *param)
648
{
649 650
	transport_local *t;

651 652
	GIT_UNUSED(param);

653
	t = git__calloc(1, sizeof(transport_local));
654
	GITERR_CHECK_ALLOC(t);
655

656
	t->parent.version = GIT_TRANSPORT_VERSION;
657
	t->parent.connect = local_connect;
658
	t->parent.negotiate_fetch = local_negotiate_fetch;
659
	t->parent.download_pack = local_download_pack;
660
	t->parent.push = local_push;
661 662
	t->parent.close = local_close;
	t->parent.free = local_free;
663 664 665 666
	t->parent.ls = local_ls;
	t->parent.is_connected = local_is_connected;
	t->parent.read_flags = local_read_flags;
	t->parent.cancel = local_cancel;
667

668
	git_vector_init(&t->refs, 0, NULL);
669 670
	t->owner = owner;

671
	*out = (git_transport *) t;
672

673
	return 0;
674
}