object.c 14 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6
 */
7 8 9

#include "object.h"

10 11 12 13
#include "git2/object.h"

#include "repository.h"

14
#include "buf.h"
15
#include "commit.h"
16
#include "hash.h"
17 18
#include "tree.h"
#include "blob.h"
19
#include "oid.h"
20 21
#include "tag.h"

22
bool git_object__strict_input_validation = true;
23

24
extern int git_odb_hash(git_oid *out, const void *data, size_t len, git_object_t type);
25
size_t git_object__size(git_object_t type);
26

27
typedef struct {
Vicent Marti committed
28
	const char	*str;	/* type name string */
29
	size_t		size;	/* size in bytes of the object structure */
30

31
	int  (*parse)(void *self, git_odb_object *obj);
32
	int  (*parse_raw)(void *self, const char *data, size_t size);
33 34 35 36
	void (*free)(void *self);
} git_object_def;

static git_object_def git_objects_table[] = {
37
	/* 0 = GIT_OBJECT__EXT1 */
38
	{ "", 0, NULL, NULL, NULL },
39

40
	/* 1 = GIT_OBJECT_COMMIT */
41
	{ "commit", sizeof(git_commit), git_commit__parse, git_commit__parse_raw, git_commit__free },
42

43
	/* 2 = GIT_OBJECT_TREE */
44
	{ "tree", sizeof(git_tree), git_tree__parse, git_tree__parse_raw, git_tree__free },
45

46
	/* 3 = GIT_OBJECT_BLOB */
47
	{ "blob", sizeof(git_blob), git_blob__parse, git_blob__parse_raw, git_blob__free },
48

49
	/* 4 = GIT_OBJECT_TAG */
50
	{ "tag", sizeof(git_tag), git_tag__parse, git_tag__parse_raw, git_tag__free },
51

52
	/* 5 = GIT_OBJECT__EXT2 */
53
	{ "", 0, NULL, NULL, NULL },
54
	/* 6 = GIT_OBJECT_OFS_DELTA */
55
	{ "OFS_DELTA", 0, NULL, NULL, NULL },
56
	/* 7 = GIT_OBJECT_REF_DELTA */
57
	{ "REF_DELTA", 0, NULL, NULL, NULL },
58 59
};

60 61 62 63
int git_object__from_raw(
	git_object **object_out,
	const char *data,
	size_t size,
64
	git_object_t type)
65 66 67 68 69 70
{
	git_object_def *def;
	git_object *object;
	size_t object_size;
	int error;

71
	GIT_ASSERT_ARG(object_out);
72 73 74
	*object_out = NULL;

	/* Validate type match */
75
	if (type != GIT_OBJECT_BLOB && type != GIT_OBJECT_TREE && type != GIT_OBJECT_COMMIT && type != GIT_OBJECT_TAG) {
76
		git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
77 78 79
		return GIT_ENOTFOUND;
	}

80
	if ((object_size = git_object__size(type)) == 0) {
81
		git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
82 83 84 85 86
		return GIT_ENOTFOUND;
	}

	/* Allocate and initialize base object */
	object = git__calloc(1, object_size);
87
	GIT_ERROR_CHECK_ALLOC(object);
88 89
	object->cached.flags = GIT_CACHE_STORE_PARSED;
	object->cached.type = type;
90 91
	if ((error = git_odb_hash(&object->cached.oid, data, size, type)) < 0)
		return error;
92 93 94

	/* Parse raw object data */
	def = &git_objects_table[type];
95
	GIT_ASSERT(def->free && def->parse_raw);
96

97
	if ((error = def->parse_raw(object, data, size)) < 0) {
98
		def->free(object);
99 100
		return error;
	}
101 102 103 104 105 106 107

	git_cached_obj_incref(object);
	*object_out = object;

	return 0;
}

108 109 110 111
int git_object__from_odb_object(
	git_object **object_out,
	git_repository *repo,
	git_odb_object *odb_obj,
112
	git_object_t type)
113 114
{
	int error;
115 116
	size_t object_size;
	git_object_def *def;
117 118
	git_object *object = NULL;

119
	GIT_ASSERT_ARG(object_out);
120 121 122
	*object_out = NULL;

	/* Validate type match */
123
	if (type != GIT_OBJECT_ANY && type != odb_obj->cached.type) {
124
		git_error_set(GIT_ERROR_INVALID,
125
			"the requested type does not match the type in the ODB");
126 127 128
		return GIT_ENOTFOUND;
	}

129
	if ((object_size = git_object__size(odb_obj->cached.type)) == 0) {
130
		git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
131 132 133 134 135
		return GIT_ENOTFOUND;
	}

	/* Allocate and initialize base object */
	object = git__calloc(1, object_size);
136
	GIT_ERROR_CHECK_ALLOC(object);
137 138

	git_oid_cpy(&object->cached.oid, &odb_obj->cached.oid);
Vicent Marti committed
139
	object->cached.type = odb_obj->cached.type;
140
	object->cached.size = odb_obj->cached.size;
141 142
	object->repo = repo;

143 144
	/* Parse raw object data */
	def = &git_objects_table[odb_obj->cached.type];
145
	GIT_ASSERT(def->free && def->parse);
146

147 148 149 150 151
	if ((error = def->parse(object, odb_obj)) < 0) {
		/*
		 * parse returns EINVALID on invalid data; downgrade
		 * that to a normal -1 error code.
		 */
152
		def->free(object);
153 154
		return -1;
	}
155

156 157
	*object_out = git_cache_store_parsed(&repo->objects, object);
	return 0;
158 159
}

160 161
void git_object__free(void *obj)
{
162
	git_object_t type = ((git_object *)obj)->cached.type;
163 164 165 166 167 168 169 170

	if (type < 0 || ((size_t)type) >= ARRAY_SIZE(git_objects_table) ||
		!git_objects_table[type].free)
		git__free(obj);
	else
		git_objects_table[type].free(obj);
}

171 172 173 174
int git_object_lookup_prefix(
	git_object **object_out,
	git_repository *repo,
	const git_oid *id,
175
	size_t len,
176
	git_object_t type)
177 178
{
	git_object *object = NULL;
179
	git_odb *odb = NULL;
180
	git_odb_object *odb_obj = NULL;
181
	int error = 0;
182

183 184 185
	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(object_out);
	GIT_ASSERT_ARG(id);
186

187
	if (len < GIT_OID_MINPREFIXLEN) {
188
		git_error_set(GIT_ERROR_OBJECT, "ambiguous lookup - OID prefix is too short");
189
		return GIT_EAMBIGUOUS;
190
	}
Vicent Marti committed
191

192
	error = git_repository_odb__weakptr(&odb, repo);
193
	if (error < 0)
194 195
		return error;

196 197
	if (len > GIT_OID_HEXSZ)
		len = GIT_OID_HEXSZ;
198

199
	if (len == GIT_OID_HEXSZ) {
200 201
		git_cached_obj *cached = NULL;

202 203 204
		/* We want to match the full id : we can first look up in the cache,
		 * since there is no need to check for non ambiguousity
		 */
205 206 207 208 209
		cached = git_cache_get_any(&repo->objects, id);
		if (cached != NULL) {
			if (cached->flags == GIT_CACHE_STORE_PARSED) {
				object = (git_object *)cached;

210
				if (type != GIT_OBJECT_ANY && type != object->cached.type) {
211
					git_object_free(object);
212
					git_error_set(GIT_ERROR_INVALID,
213
						"the requested type does not match the type in the ODB");
214 215 216 217 218 219 220 221
					return GIT_ENOTFOUND;
				}

				*object_out = object;
				return 0;
			} else if (cached->flags == GIT_CACHE_STORE_RAW) {
				odb_obj = (git_odb_object *)cached;
			} else {
222
				GIT_ASSERT(!"Wrong caching type in the global object cache");
223
			}
224 225 226 227 228 229 230
		} else {
			/* Object was not found in the cache, let's explore the backends.
			 * We could just use git_odb_read_unique_short_oid,
			 * it is the same cost for packed and loose object backends,
			 * but it may be much more costly for sqlite and hiredis.
			 */
			error = git_odb_read(&odb_obj, odb, id);
231 232
		}
	} else {
233
		git_oid short_oid = {{ 0 }};
234

235
		git_oid__cpy_prefix(&short_oid, id, len);
236

237
		/* If len < GIT_OID_HEXSZ (a strict short oid was given), we have
238 239
		 * 2 options :
		 * - We always search in the cache first. If we find that short oid is
Vicent Marti committed
240 241 242 243
		 *	ambiguous, we can stop. But in all the other cases, we must then
		 *	explore all the backends (to find an object if there was match,
		 *	or to check that oid is not ambiguous if we have found 1 match in
		 *	the cache)
244 245 246
		 * - We never explore the cache, go right to exploring the backends
		 * We chose the latter : we explore directly the backends.
		 */
247
		error = git_odb_read_prefix(&odb_obj, odb, &short_oid, len);
248 249
	}

250
	if (error < 0)
Russell Belfer committed
251
		return error;
252

253
	GIT_ASSERT(odb_obj);
254
	error = git_object__from_odb_object(object_out, repo, odb_obj, type);
255

256
	git_odb_object_free(odb_obj);
Vicent Marti committed
257

258
	return error;
259 260
}

261
int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_object_t type) {
Vicent Marti committed
262
	return git_object_lookup_prefix(object_out, repo, id, GIT_OID_HEXSZ, type);
263 264
}

265
void git_object_free(git_object *object)
266 267 268 269
{
	if (object == NULL)
		return;

270
	git_cached_obj_decref(object);
271 272
}

273
const git_oid *git_object_id(const git_object *obj)
274
{
275
	GIT_ASSERT_ARG_WITH_RETVAL(obj, NULL);
Vicent Marti committed
276
	return &obj->cached.oid;
277 278
}

279
git_object_t git_object_type(const git_object *obj)
280
{
281
	GIT_ASSERT_ARG_WITH_RETVAL(obj, GIT_OBJECT_INVALID);
Vicent Marti committed
282
	return obj->cached.type;
283 284
}

285
git_repository *git_object_owner(const git_object *obj)
286
{
287
	GIT_ASSERT_ARG_WITH_RETVAL(obj, NULL);
288 289 290
	return obj->repo;
}

291
const char *git_object_type2string(git_object_t type)
292 293 294 295 296 297 298
{
	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
		return "";

	return git_objects_table[type].str;
}

299
git_object_t git_object_string2type(const char *str)
300
{
301
	if (!str)
302
		return GIT_OBJECT_INVALID;
303 304 305 306

	return git_object_stringn2type(str, strlen(str));
}

307
git_object_t git_object_stringn2type(const char *str, size_t len)
308
{
309 310
	size_t i;

311
	if (!str || !len || !*str)
312
		return GIT_OBJECT_INVALID;
313 314

	for (i = 0; i < ARRAY_SIZE(git_objects_table); i++)
315 316
		if (*git_objects_table[i].str &&
			!git__prefixncmp(str, len, git_objects_table[i].str))
317
			return (git_object_t)i;
318

319
	return GIT_OBJECT_INVALID;
320 321
}

322
int git_object_typeisloose(git_object_t type)
323 324 325 326
{
	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
		return 0;

327
	return (git_objects_table[type].size > 0) ? 1 : 0;
328 329
}

330
size_t git_object__size(git_object_t type)
331 332 333 334 335 336 337
{
	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
		return 0;

	return git_objects_table[type].size;
}

338 339
static int dereference_object(git_object **dereferenced, git_object *obj)
{
340
	git_object_t type = git_object_type(obj);
341 342

	switch (type) {
343
	case GIT_OBJECT_COMMIT:
344 345
		return git_commit_tree((git_tree **)dereferenced, (git_commit*)obj);

346
	case GIT_OBJECT_TAG:
347
		return git_tag_target(dereferenced, (git_tag*)obj);
348

349 350
	case GIT_OBJECT_BLOB:
	case GIT_OBJECT_TREE:
351
		return GIT_EPEEL;
352 353

	default:
354
		return GIT_EINVALIDSPEC;
355 356 357
	}
}

358
static int peel_error(int error, const git_oid *oid, git_object_t type)
359 360 361 362 363 364 365 366 367
{
	const char *type_name;
	char hex_oid[GIT_OID_HEXSZ + 1];

	type_name = git_object_type2string(type);

	git_oid_fmt(hex_oid, oid);
	hex_oid[GIT_OID_HEXSZ] = '\0';

368
	git_error_set(GIT_ERROR_OBJECT, "the git_object of id '%s' can not be "
369
		"successfully peeled into a %s (git_object_t=%i).", hex_oid, type_name, type);
370 371 372 373

	return error;
}

374
static int check_type_combination(git_object_t type, git_object_t target)
375 376 377 378 379
{
	if (type == target)
		return 0;

	switch (type) {
380 381
	case GIT_OBJECT_BLOB:
	case GIT_OBJECT_TREE:
382 383 384
		/* a blob or tree can never be peeled to anything but themselves */
		return GIT_EINVALIDSPEC;
		break;
385
	case GIT_OBJECT_COMMIT:
386
		/* a commit can only be peeled to a tree */
387
		if (target != GIT_OBJECT_TREE && target != GIT_OBJECT_ANY)
388 389
			return GIT_EINVALIDSPEC;
		break;
390
	case GIT_OBJECT_TAG:
391 392 393 394 395 396 397 398 399
		/* a tag may point to anything, so we let anything through */
		break;
	default:
		return GIT_EINVALIDSPEC;
	}

	return 0;
}

400
int git_object_peel(
401
	git_object **peeled,
Vicent Marti committed
402
	const git_object *object,
403
	git_object_t target_type)
404 405
{
	git_object *source, *deref = NULL;
406 407
	int error;

408 409
	GIT_ASSERT_ARG(object);
	GIT_ASSERT_ARG(peeled);
410

411
	GIT_ASSERT_ARG(target_type == GIT_OBJECT_TAG ||
412 413 414 415
		target_type == GIT_OBJECT_COMMIT ||
		target_type == GIT_OBJECT_TREE ||
		target_type == GIT_OBJECT_BLOB ||
		target_type == GIT_OBJECT_ANY);
416

417 418 419 420 421 422
	if ((error = check_type_combination(git_object_type(object), target_type)) < 0)
		return peel_error(error, git_object_id(object), target_type);

	if (git_object_type(object) == target_type)
		return git_object_dup(peeled, (git_object *)object);

Vicent Marti committed
423
	source = (git_object *)object;
424

425
	while (!(error = dereference_object(&deref, source))) {
426 427 428 429 430 431 432 433 434

		if (source != object)
			git_object_free(source);

		if (git_object_type(deref) == target_type) {
			*peeled = deref;
			return 0;
		}

435
		if (target_type == GIT_OBJECT_ANY &&
436 437 438 439 440 441
			git_object_type(deref) != git_object_type(object))
		{
			*peeled = deref;
			return 0;
		}

442 443 444 445 446 447
		source = deref;
		deref = NULL;
	}

	if (source != object)
		git_object_free(source);
448

449
	git_object_free(deref);
450 451 452 453 454

	if (error)
		error = peel_error(error, git_object_id(object), target_type);

	return error;
455
}
456

457 458 459 460 461 462
int git_object_dup(git_object **dest, git_object *source)
{
	git_cached_obj_incref(source);
	*dest = source;
	return 0;
}
Ben Straub committed
463 464 465 466 467

int git_object_lookup_bypath(
		git_object **out,
		const git_object *treeish,
		const char *path,
468
		git_object_t type)
Ben Straub committed
469 470 471 472 473
{
	int error = -1;
	git_tree *tree = NULL;
	git_tree_entry *entry = NULL;

474 475 476
	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(treeish);
	GIT_ASSERT_ARG(path);
Ben Straub committed
477

478
	if ((error = git_object_peel((git_object**)&tree, treeish, GIT_OBJECT_TREE)) < 0 ||
479
		 (error = git_tree_entry_bypath(&entry, tree, path)) < 0)
Ben Straub committed
480 481 482 483
	{
		goto cleanup;
	}

484
	if (type != GIT_OBJECT_ANY && git_tree_entry_type(entry) != type)
485
	{
486
		git_error_set(GIT_ERROR_OBJECT,
Ben Straub committed
487 488 489
				"object at path '%s' is not of the asked-for type %d",
				path, type);
		error = GIT_EINVALIDSPEC;
490
		goto cleanup;
Ben Straub committed
491 492
	}

493 494
	error = git_tree_entry_to_object(out, git_object_owner(treeish), entry);

Ben Straub committed
495 496 497 498 499
cleanup:
	git_tree_entry_free(entry);
	git_tree_free(tree);
	return error;
}
500

501
static int git_object__short_id(git_str *out, const git_object *obj)
502 503 504 505 506 507
{
	git_repository *repo;
	int len = GIT_ABBREV_DEFAULT, error;
	git_oid id = {{0}};
	git_odb *odb;

508 509
	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(obj);
510 511 512

	repo = git_object_owner(obj);

513
	if ((error = git_repository__configmap_lookup(&len, repo, GIT_CONFIGMAP_ABBREV)) < 0)
514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
		return error;

	if ((error = git_repository_odb(&odb, repo)) < 0)
		return error;

	while (len < GIT_OID_HEXSZ) {
		/* set up short oid */
		memcpy(&id.id, &obj->cached.oid.id, (len + 1) / 2);
		if (len & 1)
			id.id[len / 2] &= 0xf0;

		error = git_odb_exists_prefix(NULL, odb, &id, len);
		if (error != GIT_EAMBIGUOUS)
			break;

529
		git_error_clear();
530 531 532
		len++;
	}

533
	if (!error && !(error = git_str_grow(out, len + 1))) {
534 535 536 537 538 539 540 541 542
		git_oid_tostr(out->ptr, len + 1, &id);
		out->size = len;
	}

	git_odb_free(odb);

	return error;
}

543 544 545 546 547
int git_object_short_id(git_buf *out, const git_object *obj)
{
	GIT_BUF_WRAP_PRIVATE(out, git_object__short_id, obj);
}

548
bool git_object__is_valid(
549
	git_repository *repo, const git_oid *id, git_object_t expected_type)
550 551
{
	git_odb *odb;
552
	git_object_t actual_type;
553 554 555 556 557 558 559 560 561 562
	size_t len;
	int error;

	if (!git_object__strict_input_validation)
		return true;

	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||
		(error = git_odb_read_header(&len, &actual_type, odb, id)) < 0)
		return false;

563
	if (expected_type != GIT_OBJECT_ANY && expected_type != actual_type) {
564
		git_error_set(GIT_ERROR_INVALID,
565 566 567 568 569 570
			"the requested type does not match the type in the ODB");
		return false;
	}

	return true;
}
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602

int git_object_rawcontent_is_valid(
	int *valid,
	const char *buf,
	size_t len,
	git_object_t type)
{
	git_object *obj = NULL;
	int error;

	GIT_ASSERT_ARG(valid);
	GIT_ASSERT_ARG(buf);

	/* Blobs are always valid; don't bother parsing. */
	if (type == GIT_OBJECT_BLOB) {
		*valid = 1;
		return 0;
	}

	error = git_object__from_raw(&obj, buf, len, type);
	git_object_free(obj);

	if (error == 0) {
		*valid = 1;
		return 0;
	} else if (error == GIT_EINVALID) {
		*valid = 0;
		return 0;
	}

	return error;
}