local.c 14.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 39
	git_vector refs;
	unsigned connected : 1;
40
} transport_local;
41

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

50
	head = git__calloc(1, sizeof(git_remote_head));
51
	GITERR_CHECK_ALLOC(head);
52

53 54
	head->name = git__strdup(name);
	GITERR_CHECK_ALLOC(head->name);
55

56 57
	error = git_reference_name_to_id(&head->oid, t->repo, name);
	if (error < 0) {
58
		git__free(head->name);
59
		git__free(head);
60
		if (!strcmp(name, GIT_HEAD_FILE) && error == GIT_ENOTFOUND) {
61
			/* This is actually okay.  Empty repos often have a HEAD that points to
62
			 * a nonexistent "refs/heads/master". */
63 64 65 66
			giterr_clear();
			return 0;
		}
		return error;
67 68
	}

69
	if (git_vector_insert(&t->refs, head) < 0)
70
	{
71 72
		git__free(head->name);
		git__free(head);
73
		return -1;
74
	}
75 76 77

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

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

83 84
	head = NULL;

85 86 87 88
	/* 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) {
89 90 91
		git_object_free(obj);
		return 0;
	}
92 93

	/* And if it's a tag, peel it, and add it to the list */
94
	head = git__calloc(1, sizeof(git_remote_head));
95 96 97
	GITERR_CHECK_ALLOC(head);
	if (git_buf_join(&buf, 0, name, peeled) < 0)
		return -1;
98

99
	head->name = git_buf_detach(&buf);
100

101 102
	if (git_tag_peel(&target, (git_tag *) obj) < 0)
		goto on_error;
103

104 105 106
	git_oid_cpy(&head->oid, git_object_id(target));
	git_object_free(obj);
	git_object_free(target);
107

108
	if (git_vector_insert(&t->refs, head) < 0)
109
		return -1;
110

111
	return 0;
112

113
on_error:
114
	git_object_free(obj);
115 116
	git_object_free(target);
	return -1;
117 118
}

119
static int store_refs(transport_local *t)
120
{
121
	unsigned int i;
122
	git_strarray ref_names = {0};
123

124
	assert(t);
125

126
	if (git_reference_list(&ref_names, t->repo, GIT_REF_LISTALL) < 0 ||
127
		git_vector_init(&t->refs, ref_names.count, NULL) < 0)
128
		goto on_error;
129

130
	/* Sort the references first */
131
	git__tsort((void **)ref_names.strings, ref_names.count, &git__strcmp_cb);
132

133 134
	/* Add HEAD iff direction is fetch */
	if (t->direction == GIT_DIRECTION_FETCH && add_ref(t, GIT_HEAD_FILE) < 0)
135
		goto on_error;
136

137
	for (i = 0; i < ref_names.count; ++i) {
138 139
		if (add_ref(t, ref_names.strings[i]) < 0)
			goto on_error;
140
	}
141

142
	git_strarray_free(&ref_names);
143 144 145
	return 0;

on_error:
146
	git_vector_free(&t->refs);
147
	git_strarray_free(&ref_names);
148
	return -1;
149
}
150

151 152 153 154
/*
 * Try to open the url as a git directory. The direction doesn't
 * matter in this case because we're calulating the heads ourselves.
 */
155 156 157 158
static int local_connect(
	git_transport *transport,
	const char *url,
	git_cred_acquire_cb cred_acquire_cb,
159
	void *cred_acquire_payload,
160
	int direction, int flags)
161 162 163 164 165
{
	git_repository *repo;
	int error;
	transport_local *t = (transport_local *) transport;
	const char *path;
166 167
	git_buf buf = GIT_BUF_INIT;

168
	GIT_UNUSED(cred_acquire_cb);
169
	GIT_UNUSED(cred_acquire_payload);
170

171 172 173 174
	t->url = git__strdup(url);
	GITERR_CHECK_ALLOC(t->url);
	t->direction = direction;
	t->flags = flags;
175 176

	/* The repo layer doesn't want the prefix */
177 178
	if (!git__prefixcmp(t->url, "file://")) {
		if (git_path_fromurl(&buf, t->url) < 0) {
179
			git_buf_free(&buf);
180
			return -1;
181 182 183
		}
		path = git_buf_cstr(&buf);

184
	} else { /* We assume transport->url is already a path */
185
		path = t->url;
186
	}
187 188

	error = git_repository_open(&repo, path);
189 190 191

	git_buf_free(&buf);

192 193
	if (error < 0)
		return -1;
194

195 196
	t->repo = repo;

197 198
	if (store_refs(t) < 0)
		return -1;
199

200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
	t->connected = 1;

	return 0;
}

static int local_ls(git_transport *transport, git_headlist_cb list_cb, void *payload)
{
	transport_local *t = (transport_local *)transport;
	unsigned int i;
	git_remote_head *head = NULL;

	if (!t->connected) {
		giterr_set(GITERR_NET, "The transport is not connected");
		return -1;
	}

	git_vector_foreach(&t->refs, i, head) {
		if (list_cb(head, payload))
			return GIT_EUSER;
	}
220

221
	return 0;
222 223
}

224 225 226
static int local_negotiate_fetch(
	git_transport *transport,
	git_repository *repo,
227 228
	const git_remote_head * const *refs,
	size_t count)
229
{
230 231 232 233
	transport_local *t = (transport_local*)transport;
	git_remote_head *rhead;
	unsigned int i;

234 235
	GIT_UNUSED(refs);
	GIT_UNUSED(count);
236

237 238 239 240 241 242 243 244 245
	/* 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;
nulltoken committed
246
		git_object_free(obj);
247 248 249 250 251 252
		giterr_clear();
	}

	return 0;
}

253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 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 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 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 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 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
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;

	if (odb_stream->write(odb_stream, (char *)git_odb_object_data(odb_obj),
		odb_obj_size) < 0 ||
		odb_stream->finalize_write(&remote_odb_obj_oid, odb_stream) < 0) {
		error = -1;
	} else if (git_oid_cmp(&obj->id, &remote_odb_obj_oid) != 0) {
		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;
	}

	odb_stream->free(odb_stream);

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,
				!git_oid_iszero(roid))) < 0)
			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;
	int error;
	unsigned int i;
	size_t j;

	if ((error = git_repository_open(&remote_repo, push->remote->url)) < 0)
		return error;

	/* We don't currently support pushing locally to non-bare repos. Proper 
	   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) {
		error = -1;
		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,
			push->remote->cred_acquire_cb, NULL, GIT_DIRECTION_PUSH, flags))
			goto on_error;
	}

	error = 0;

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

	return error;
}

438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
typedef struct foreach_data {
	git_transfer_progress *stats;
	git_transfer_progress_callback progress_cb;
	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;
	return data->writepack->add(data->writepack, buf, len, data->stats);
}

static int local_download_pack(
		git_transport *transport,
		git_repository *repo,
		git_transfer_progress *stats,
		git_transfer_progress_callback progress_cb,
		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;
468
	git_odb *odb = NULL;
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499

	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);
		}
      git_object_free(obj);
	}

	/* Walk the objects, building a packfile */
500 501
	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
		goto cleanup;
502 503 504 505

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

506 507 508
		/* Skip commits we already have */
		if (git_odb_exists(odb, &oid)) continue;

509
		if (!git_object_lookup((git_object**)&commit, t->repo, &oid, GIT_OBJ_COMMIT)) {
Vicent Marti committed
510
			const git_oid *tree_oid = git_commit_tree_id(commit);
511 512 513

			/* Add the commit and its tree */
			if ((error = git_packbuilder_insert(pack, &oid, NULL)) < 0 ||
514 515
				 (error = git_packbuilder_insert_tree(pack, tree_oid)) < 0) {
				git_commit_free(commit);
516
				goto cleanup;
517 518 519
			}

			git_commit_free(commit);
520 521 522
		}
	}

523 524
	if ((error = git_odb_write_pack(&writepack, odb, progress_cb, progress_payload)) < 0)
		goto cleanup;
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543

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

		if ((error = git_packbuilder_foreach(pack, foreach_cb, &data)) < 0)
			goto cleanup;
	}
	error = writepack->commit(writepack, stats);

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

546
static int local_is_connected(git_transport *transport)
547 548 549
{
	transport_local *t = (transport_local *)transport;

550
	return t->connected;
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
}

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

569
static int local_close(git_transport *transport)
570
{
571
	transport_local *t = (transport_local *)transport;
572 573
	size_t i;
	git_remote_head *head;
574

575
	t->connected = 0;
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592

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

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

	git_vector_free(&t->refs);

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

594
	return 0;
595 596
}

597 598
static void local_free(git_transport *transport)
{
599
	transport_local *t = (transport_local *)transport;
600

601 602
	/* Close the transport, if it's still open. */
	local_close(transport);
603

604
	/* Free the transport */
605
	git__free(t);
606 607
}

608 609 610 611
/**************
 * Public API *
 **************/

612
int git_transport_local(git_transport **out, git_remote *owner, void *param)
613
{
614 615
	transport_local *t;

616 617
	GIT_UNUSED(param);

618
	t = git__calloc(1, sizeof(transport_local));
619
	GITERR_CHECK_ALLOC(t);
620

621
	t->parent.version = GIT_TRANSPORT_VERSION;
622
	t->parent.connect = local_connect;
623
	t->parent.negotiate_fetch = local_negotiate_fetch;
624
	t->parent.download_pack = local_download_pack;
625
	t->parent.push = local_push;
626 627
	t->parent.close = local_close;
	t->parent.free = local_free;
628 629 630 631
	t->parent.ls = local_ls;
	t->parent.is_connected = local_is_connected;
	t->parent.read_flags = local_read_flags;
	t->parent.cancel = local_cancel;
632

633 634
	t->owner = owner;

635
	*out = (git_transport *) t;
636

637
	return 0;
638
}