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 44 45 46 47 48 49
static void free_head(git_remote_head *head)
{
	git__free(head->name);
	git__free(head->symref_target);
	git__free(head);
}

50
static int add_ref(transport_local *t, const char *name)
51 52
{
	const char peeled[] = "^{}";
53
	git_reference *ref, *resolved;
54
	git_remote_head *head;
55
	git_oid obj_id;
56 57
	git_object *obj = NULL, *target = NULL;
	git_buf buf = GIT_BUF_INIT;
58
	int error;
59

60 61 62 63
	if ((error = git_reference_lookup(&ref, t->repo, name)) < 0)
		return error;

	error = git_reference_resolve(&resolved, ref);
64
	if (error < 0) {
65
		git_reference_free(ref);
66
		if (!strcmp(name, GIT_HEAD_FILE) && error == GIT_ENOTFOUND) {
67 68
			/* This is actually okay.  Empty repos often have a HEAD that
			 * points to a nonexistent "refs/heads/master". */
69 70 71 72
			giterr_clear();
			return 0;
		}
		return error;
73 74
	}

75 76 77
	git_oid_cpy(&obj_id, git_reference_target(resolved));
	git_reference_free(resolved);

78 79 80 81 82 83
	head = git__calloc(1, sizeof(git_remote_head));
	GITERR_CHECK_ALLOC(head);

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

84 85 86 87 88 89 90
	git_oid_cpy(&head->oid, &obj_id);

	if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
		head->symref_target = git__strdup(git_reference_symbolic_target(ref));
		GITERR_CHECK_ALLOC(head->symref_target);
	}
	git_reference_free(ref);
91 92

	if ((error = git_vector_insert(&t->refs, head)) < 0) {
93
		free_head(head);
94
		return error;
95
	}
96 97 98

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

101 102
	if ((error = git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY)) < 0)
		return error;
103

104 105
	head = NULL;

106 107 108 109
	/* 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) {
110 111 112
		git_object_free(obj);
		return 0;
	}
113 114

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

118 119 120
	if (git_buf_join(&buf, 0, name, peeled) < 0)
		return -1;
	head->name = git_buf_detach(&buf);
121

122 123
	if (!(error = git_tag_peel(&target, (git_tag *)obj))) {
		git_oid_cpy(&head->oid, git_object_id(target));
124

125
		if ((error = git_vector_insert(&t->refs, head)) < 0) {
126
			free_head(head);
127 128
		}
	}
129

130
	git_object_free(obj);
131
	git_object_free(target);
132 133

	return error;
134 135
}

136
static int store_refs(transport_local *t)
137
{
138 139
	size_t i;
	git_remote_head *head;
140
	git_strarray ref_names = {0};
141

142
	assert(t);
143

144
	if (git_reference_list(&ref_names, t->repo) < 0)
145
		goto on_error;
146

147 148 149 150 151 152 153 154 155
	/* 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);

156
	/* Sort the references first */
157
	git__tsort((void **)ref_names.strings, ref_names.count, &git__strcmp_cb);
158

159 160
	/* Add HEAD iff direction is fetch */
	if (t->direction == GIT_DIRECTION_FETCH && add_ref(t, GIT_HEAD_FILE) < 0)
161
		goto on_error;
162

163
	for (i = 0; i < ref_names.count; ++i) {
164 165
		if (add_ref(t, ref_names.strings[i]) < 0)
			goto on_error;
166
	}
167

168
	t->have_refs = 1;
169
	git_strarray_free(&ref_names);
170 171 172
	return 0;

on_error:
173
	git_vector_free(&t->refs);
174
	git_strarray_free(&ref_names);
175
	return -1;
176
}
177

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

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

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

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

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

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

	git_buf_free(&buf);

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

220 221
	t->repo = repo;

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

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

	return 0;
}

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

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

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

242
	return 0;
243 244
}

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

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

258 259 260 261 262 263 264 265 266
	/* 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;
267 268
		else
			giterr_clear();
nulltoken committed
269
		git_object_free(obj);
270 271 272 273 274
	}

	return 0;
}

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 300
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;

301
	if (git_odb_stream_write(odb_stream, (char *)git_odb_object_data(odb_obj),
302
		odb_obj_size) < 0 ||
303
		git_odb_stream_finalize_write(&remote_odb_obj_oid, odb_stream) < 0) {
304
		error = -1;
305
	} else if (git_oid__cmp(&obj->id, &remote_odb_obj_oid) != 0) {
306 307 308 309 310 311
		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;
	}

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

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,
335
				!git_oid_iszero(roid), NULL, NULL)) < 0)
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 363
			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;
364 365
	const char *path;
	git_buf buf = GIT_BUF_INIT;
366 367 368 369
	int error;
	unsigned int i;
	size_t j;

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

	error = git_repository_open(&remote_repo, path);

	git_buf_free(&buf);

	if (error < 0)
382 383
		return error;

nulltoken committed
384
	/* We don't currently support pushing locally to non-bare repos. Proper
385 386 387
	   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) {
388 389
		error = GIT_EBAREREPO;
		giterr_set(GITERR_INVALID, "Local push doesn't (yet) support pushing to non-bare repos.");
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 460
		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,
461
			push->remote->callbacks.credentials, NULL, GIT_DIRECTION_PUSH, flags))
462 463 464 465 466 467 468 469 470 471 472 473
			goto on_error;
	}

	error = 0;

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

	return error;
}

474 475
typedef struct foreach_data {
	git_transfer_progress *stats;
476
	git_transfer_progress_cb progress_cb;
477 478 479 480 481 482 483 484 485
	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;
486
	return data->writepack->append(data->writepack, buf, len, data->stats);
487 488 489 490 491 492
}

static int local_download_pack(
		git_transport *transport,
		git_repository *repo,
		git_transfer_progress *stats,
493
		git_transfer_progress_cb progress_cb,
494 495 496 497 498 499 500 501 502 503
		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;
504
	git_odb *odb = NULL;
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 531

	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
532
		git_object_free(obj);
533 534 535
	}

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

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

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

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

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

			git_commit_free(commit);
556 557 558
		}
	}

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

	/* 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;

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

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

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

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

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);
}

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

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

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

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

621
	return 0;
622 623
}

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

630 631
	git_vector_foreach(&t->refs, i, head)
		free_head(head);
632

633 634
	git_vector_free(&t->refs);

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

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

642 643 644 645
/**************
 * Public API *
 **************/

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

650 651
	GIT_UNUSED(param);

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

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

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

670
	*out = (git_transport *) t;
671

672
	return 0;
673
}