1 /*
2 * Copyright (C) the libgit2 contributors. All rights reserved.
3 *
4 * This file is part of libgit2, distributed under the GNU GPL v2 with
5 * a Linking Exception. For full terms see the included COPYING file.
6 */
7
8 #include "object.h"
9
10 #include "git2/object.h"
11
12 #include "repository.h"
13
14 #include "commit.h"
15 #include "hash.h"
16 #include "tree.h"
17 #include "blob.h"
18 #include "oid.h"
19 #include "tag.h"
20
21 bool git_object__strict_input_validation = true;
22
23 extern int git_odb_hash(git_oid *out, const void *data, size_t len, git_object_t type);
24 size_t git_object__size(git_object_t type);
25
26 typedef struct {
27 const char *str; /* type name string */
28 size_t size; /* size in bytes of the object structure */
29
30 int (*parse)(void *self, git_odb_object *obj);
31 int (*parse_raw)(void *self, const char *data, size_t size);
32 void (*free)(void *self);
33 } git_object_def;
34
35 static git_object_def git_objects_table[] = {
36 /* 0 = GIT_OBJECT__EXT1 */
37 { "", 0, NULL, NULL, NULL },
38
39 /* 1 = GIT_OBJECT_COMMIT */
40 { "commit", sizeof(git_commit), git_commit__parse, git_commit__parse_raw, git_commit__free },
41
42 /* 2 = GIT_OBJECT_TREE */
43 { "tree", sizeof(git_tree), git_tree__parse, git_tree__parse_raw, git_tree__free },
44
45 /* 3 = GIT_OBJECT_BLOB */
46 { "blob", sizeof(git_blob), git_blob__parse, git_blob__parse_raw, git_blob__free },
47
48 /* 4 = GIT_OBJECT_TAG */
49 { "tag", sizeof(git_tag), git_tag__parse, git_tag__parse_raw, git_tag__free },
50
51 /* 5 = GIT_OBJECT__EXT2 */
52 { "", 0, NULL, NULL, NULL },
53 /* 6 = GIT_OBJECT_OFS_DELTA */
54 { "OFS_DELTA", 0, NULL, NULL, NULL },
55 /* 7 = GIT_OBJECT_REF_DELTA */
56 { "REF_DELTA", 0, NULL, NULL, NULL },
57 };
58
git_object__from_raw(git_object ** object_out,const char * data,size_t size,git_object_t type)59 int git_object__from_raw(
60 git_object **object_out,
61 const char *data,
62 size_t size,
63 git_object_t type)
64 {
65 git_object_def *def;
66 git_object *object;
67 size_t object_size;
68 int error;
69
70 GIT_ASSERT_ARG(object_out);
71 *object_out = NULL;
72
73 /* Validate type match */
74 if (type != GIT_OBJECT_BLOB && type != GIT_OBJECT_TREE && type != GIT_OBJECT_COMMIT && type != GIT_OBJECT_TAG) {
75 git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
76 return GIT_ENOTFOUND;
77 }
78
79 if ((object_size = git_object__size(type)) == 0) {
80 git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
81 return GIT_ENOTFOUND;
82 }
83
84 /* Allocate and initialize base object */
85 object = git__calloc(1, object_size);
86 GIT_ERROR_CHECK_ALLOC(object);
87 object->cached.flags = GIT_CACHE_STORE_PARSED;
88 object->cached.type = type;
89 if ((error = git_odb_hash(&object->cached.oid, data, size, type)) < 0)
90 return error;
91
92 /* Parse raw object data */
93 def = &git_objects_table[type];
94 GIT_ASSERT(def->free && def->parse_raw);
95
96 if ((error = def->parse_raw(object, data, size)) < 0) {
97 def->free(object);
98 return error;
99 }
100
101 git_cached_obj_incref(object);
102 *object_out = object;
103
104 return 0;
105 }
106
git_object__from_odb_object(git_object ** object_out,git_repository * repo,git_odb_object * odb_obj,git_object_t type)107 int git_object__from_odb_object(
108 git_object **object_out,
109 git_repository *repo,
110 git_odb_object *odb_obj,
111 git_object_t type)
112 {
113 int error;
114 size_t object_size;
115 git_object_def *def;
116 git_object *object = NULL;
117
118 GIT_ASSERT_ARG(object_out);
119 *object_out = NULL;
120
121 /* Validate type match */
122 if (type != GIT_OBJECT_ANY && type != odb_obj->cached.type) {
123 git_error_set(GIT_ERROR_INVALID,
124 "the requested type does not match the type in the ODB");
125 return GIT_ENOTFOUND;
126 }
127
128 if ((object_size = git_object__size(odb_obj->cached.type)) == 0) {
129 git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
130 return GIT_ENOTFOUND;
131 }
132
133 /* Allocate and initialize base object */
134 object = git__calloc(1, object_size);
135 GIT_ERROR_CHECK_ALLOC(object);
136
137 git_oid_cpy(&object->cached.oid, &odb_obj->cached.oid);
138 object->cached.type = odb_obj->cached.type;
139 object->cached.size = odb_obj->cached.size;
140 object->repo = repo;
141
142 /* Parse raw object data */
143 def = &git_objects_table[odb_obj->cached.type];
144 GIT_ASSERT(def->free && def->parse);
145
146 if ((error = def->parse(object, odb_obj)) < 0)
147 def->free(object);
148 else
149 *object_out = git_cache_store_parsed(&repo->objects, object);
150
151 return error;
152 }
153
git_object__free(void * obj)154 void git_object__free(void *obj)
155 {
156 git_object_t type = ((git_object *)obj)->cached.type;
157
158 if (type < 0 || ((size_t)type) >= ARRAY_SIZE(git_objects_table) ||
159 !git_objects_table[type].free)
160 git__free(obj);
161 else
162 git_objects_table[type].free(obj);
163 }
164
git_object_lookup_prefix(git_object ** object_out,git_repository * repo,const git_oid * id,size_t len,git_object_t type)165 int git_object_lookup_prefix(
166 git_object **object_out,
167 git_repository *repo,
168 const git_oid *id,
169 size_t len,
170 git_object_t type)
171 {
172 git_object *object = NULL;
173 git_odb *odb = NULL;
174 git_odb_object *odb_obj = NULL;
175 int error = 0;
176
177 GIT_ASSERT_ARG(repo);
178 GIT_ASSERT_ARG(object_out);
179 GIT_ASSERT_ARG(id);
180
181 if (len < GIT_OID_MINPREFIXLEN) {
182 git_error_set(GIT_ERROR_OBJECT, "ambiguous lookup - OID prefix is too short");
183 return GIT_EAMBIGUOUS;
184 }
185
186 error = git_repository_odb__weakptr(&odb, repo);
187 if (error < 0)
188 return error;
189
190 if (len > GIT_OID_HEXSZ)
191 len = GIT_OID_HEXSZ;
192
193 if (len == GIT_OID_HEXSZ) {
194 git_cached_obj *cached = NULL;
195
196 /* We want to match the full id : we can first look up in the cache,
197 * since there is no need to check for non ambiguousity
198 */
199 cached = git_cache_get_any(&repo->objects, id);
200 if (cached != NULL) {
201 if (cached->flags == GIT_CACHE_STORE_PARSED) {
202 object = (git_object *)cached;
203
204 if (type != GIT_OBJECT_ANY && type != object->cached.type) {
205 git_object_free(object);
206 git_error_set(GIT_ERROR_INVALID,
207 "the requested type does not match the type in the ODB");
208 return GIT_ENOTFOUND;
209 }
210
211 *object_out = object;
212 return 0;
213 } else if (cached->flags == GIT_CACHE_STORE_RAW) {
214 odb_obj = (git_odb_object *)cached;
215 } else {
216 GIT_ASSERT(!"Wrong caching type in the global object cache");
217 }
218 } else {
219 /* Object was not found in the cache, let's explore the backends.
220 * We could just use git_odb_read_unique_short_oid,
221 * it is the same cost for packed and loose object backends,
222 * but it may be much more costly for sqlite and hiredis.
223 */
224 error = git_odb_read(&odb_obj, odb, id);
225 }
226 } else {
227 git_oid short_oid = {{ 0 }};
228
229 git_oid__cpy_prefix(&short_oid, id, len);
230
231 /* If len < GIT_OID_HEXSZ (a strict short oid was given), we have
232 * 2 options :
233 * - We always search in the cache first. If we find that short oid is
234 * ambiguous, we can stop. But in all the other cases, we must then
235 * explore all the backends (to find an object if there was match,
236 * or to check that oid is not ambiguous if we have found 1 match in
237 * the cache)
238 * - We never explore the cache, go right to exploring the backends
239 * We chose the latter : we explore directly the backends.
240 */
241 error = git_odb_read_prefix(&odb_obj, odb, &short_oid, len);
242 }
243
244 if (error < 0)
245 return error;
246
247 error = git_object__from_odb_object(object_out, repo, odb_obj, type);
248
249 git_odb_object_free(odb_obj);
250
251 return error;
252 }
253
git_object_lookup(git_object ** object_out,git_repository * repo,const git_oid * id,git_object_t type)254 int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_object_t type) {
255 return git_object_lookup_prefix(object_out, repo, id, GIT_OID_HEXSZ, type);
256 }
257
git_object_free(git_object * object)258 void git_object_free(git_object *object)
259 {
260 if (object == NULL)
261 return;
262
263 git_cached_obj_decref(object);
264 }
265
git_object_id(const git_object * obj)266 const git_oid *git_object_id(const git_object *obj)
267 {
268 GIT_ASSERT_ARG_WITH_RETVAL(obj, NULL);
269 return &obj->cached.oid;
270 }
271
git_object_type(const git_object * obj)272 git_object_t git_object_type(const git_object *obj)
273 {
274 GIT_ASSERT_ARG_WITH_RETVAL(obj, GIT_OBJECT_INVALID);
275 return obj->cached.type;
276 }
277
git_object_owner(const git_object * obj)278 git_repository *git_object_owner(const git_object *obj)
279 {
280 GIT_ASSERT_ARG_WITH_RETVAL(obj, NULL);
281 return obj->repo;
282 }
283
git_object_type2string(git_object_t type)284 const char *git_object_type2string(git_object_t type)
285 {
286 if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
287 return "";
288
289 return git_objects_table[type].str;
290 }
291
git_object_string2type(const char * str)292 git_object_t git_object_string2type(const char *str)
293 {
294 if (!str)
295 return GIT_OBJECT_INVALID;
296
297 return git_object_stringn2type(str, strlen(str));
298 }
299
git_object_stringn2type(const char * str,size_t len)300 git_object_t git_object_stringn2type(const char *str, size_t len)
301 {
302 size_t i;
303
304 if (!str || !len || !*str)
305 return GIT_OBJECT_INVALID;
306
307 for (i = 0; i < ARRAY_SIZE(git_objects_table); i++)
308 if (*git_objects_table[i].str &&
309 !git__prefixncmp(str, len, git_objects_table[i].str))
310 return (git_object_t)i;
311
312 return GIT_OBJECT_INVALID;
313 }
314
git_object_typeisloose(git_object_t type)315 int git_object_typeisloose(git_object_t type)
316 {
317 if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
318 return 0;
319
320 return (git_objects_table[type].size > 0) ? 1 : 0;
321 }
322
git_object__size(git_object_t type)323 size_t git_object__size(git_object_t type)
324 {
325 if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
326 return 0;
327
328 return git_objects_table[type].size;
329 }
330
dereference_object(git_object ** dereferenced,git_object * obj)331 static int dereference_object(git_object **dereferenced, git_object *obj)
332 {
333 git_object_t type = git_object_type(obj);
334
335 switch (type) {
336 case GIT_OBJECT_COMMIT:
337 return git_commit_tree((git_tree **)dereferenced, (git_commit*)obj);
338
339 case GIT_OBJECT_TAG:
340 return git_tag_target(dereferenced, (git_tag*)obj);
341
342 case GIT_OBJECT_BLOB:
343 case GIT_OBJECT_TREE:
344 return GIT_EPEEL;
345
346 default:
347 return GIT_EINVALIDSPEC;
348 }
349 }
350
peel_error(int error,const git_oid * oid,git_object_t type)351 static int peel_error(int error, const git_oid *oid, git_object_t type)
352 {
353 const char *type_name;
354 char hex_oid[GIT_OID_HEXSZ + 1];
355
356 type_name = git_object_type2string(type);
357
358 git_oid_fmt(hex_oid, oid);
359 hex_oid[GIT_OID_HEXSZ] = '\0';
360
361 git_error_set(GIT_ERROR_OBJECT, "the git_object of id '%s' can not be "
362 "successfully peeled into a %s (git_object_t=%i).", hex_oid, type_name, type);
363
364 return error;
365 }
366
check_type_combination(git_object_t type,git_object_t target)367 static int check_type_combination(git_object_t type, git_object_t target)
368 {
369 if (type == target)
370 return 0;
371
372 switch (type) {
373 case GIT_OBJECT_BLOB:
374 case GIT_OBJECT_TREE:
375 /* a blob or tree can never be peeled to anything but themselves */
376 return GIT_EINVALIDSPEC;
377 break;
378 case GIT_OBJECT_COMMIT:
379 /* a commit can only be peeled to a tree */
380 if (target != GIT_OBJECT_TREE && target != GIT_OBJECT_ANY)
381 return GIT_EINVALIDSPEC;
382 break;
383 case GIT_OBJECT_TAG:
384 /* a tag may point to anything, so we let anything through */
385 break;
386 default:
387 return GIT_EINVALIDSPEC;
388 }
389
390 return 0;
391 }
392
git_object_peel(git_object ** peeled,const git_object * object,git_object_t target_type)393 int git_object_peel(
394 git_object **peeled,
395 const git_object *object,
396 git_object_t target_type)
397 {
398 git_object *source, *deref = NULL;
399 int error;
400
401 GIT_ASSERT_ARG(object);
402 GIT_ASSERT_ARG(peeled);
403
404 GIT_ASSERT_ARG(target_type == GIT_OBJECT_TAG ||
405 target_type == GIT_OBJECT_COMMIT ||
406 target_type == GIT_OBJECT_TREE ||
407 target_type == GIT_OBJECT_BLOB ||
408 target_type == GIT_OBJECT_ANY);
409
410 if ((error = check_type_combination(git_object_type(object), target_type)) < 0)
411 return peel_error(error, git_object_id(object), target_type);
412
413 if (git_object_type(object) == target_type)
414 return git_object_dup(peeled, (git_object *)object);
415
416 source = (git_object *)object;
417
418 while (!(error = dereference_object(&deref, source))) {
419
420 if (source != object)
421 git_object_free(source);
422
423 if (git_object_type(deref) == target_type) {
424 *peeled = deref;
425 return 0;
426 }
427
428 if (target_type == GIT_OBJECT_ANY &&
429 git_object_type(deref) != git_object_type(object))
430 {
431 *peeled = deref;
432 return 0;
433 }
434
435 source = deref;
436 deref = NULL;
437 }
438
439 if (source != object)
440 git_object_free(source);
441
442 git_object_free(deref);
443
444 if (error)
445 error = peel_error(error, git_object_id(object), target_type);
446
447 return error;
448 }
449
git_object_dup(git_object ** dest,git_object * source)450 int git_object_dup(git_object **dest, git_object *source)
451 {
452 git_cached_obj_incref(source);
453 *dest = source;
454 return 0;
455 }
456
git_object_lookup_bypath(git_object ** out,const git_object * treeish,const char * path,git_object_t type)457 int git_object_lookup_bypath(
458 git_object **out,
459 const git_object *treeish,
460 const char *path,
461 git_object_t type)
462 {
463 int error = -1;
464 git_tree *tree = NULL;
465 git_tree_entry *entry = NULL;
466
467 GIT_ASSERT_ARG(out);
468 GIT_ASSERT_ARG(treeish);
469 GIT_ASSERT_ARG(path);
470
471 if ((error = git_object_peel((git_object**)&tree, treeish, GIT_OBJECT_TREE)) < 0 ||
472 (error = git_tree_entry_bypath(&entry, tree, path)) < 0)
473 {
474 goto cleanup;
475 }
476
477 if (type != GIT_OBJECT_ANY && git_tree_entry_type(entry) != type)
478 {
479 git_error_set(GIT_ERROR_OBJECT,
480 "object at path '%s' is not of the asked-for type %d",
481 path, type);
482 error = GIT_EINVALIDSPEC;
483 goto cleanup;
484 }
485
486 error = git_tree_entry_to_object(out, git_object_owner(treeish), entry);
487
488 cleanup:
489 git_tree_entry_free(entry);
490 git_tree_free(tree);
491 return error;
492 }
493
git_object_short_id(git_buf * out,const git_object * obj)494 int git_object_short_id(git_buf *out, const git_object *obj)
495 {
496 git_repository *repo;
497 int len = GIT_ABBREV_DEFAULT, error;
498 git_oid id = {{0}};
499 git_odb *odb;
500
501 GIT_ASSERT_ARG(out);
502 GIT_ASSERT_ARG(obj);
503
504 if ((error = git_buf_sanitize(out)) < 0)
505 return error;
506
507 repo = git_object_owner(obj);
508
509 if ((error = git_repository__configmap_lookup(&len, repo, GIT_CONFIGMAP_ABBREV)) < 0)
510 return error;
511
512 if ((error = git_repository_odb(&odb, repo)) < 0)
513 return error;
514
515 while (len < GIT_OID_HEXSZ) {
516 /* set up short oid */
517 memcpy(&id.id, &obj->cached.oid.id, (len + 1) / 2);
518 if (len & 1)
519 id.id[len / 2] &= 0xf0;
520
521 error = git_odb_exists_prefix(NULL, odb, &id, len);
522 if (error != GIT_EAMBIGUOUS)
523 break;
524
525 git_error_clear();
526 len++;
527 }
528
529 if (!error && !(error = git_buf_grow(out, len + 1))) {
530 git_oid_tostr(out->ptr, len + 1, &id);
531 out->size = len;
532 }
533
534 git_odb_free(odb);
535
536 return error;
537 }
538
git_object__is_valid(git_repository * repo,const git_oid * id,git_object_t expected_type)539 bool git_object__is_valid(
540 git_repository *repo, const git_oid *id, git_object_t expected_type)
541 {
542 git_odb *odb;
543 git_object_t actual_type;
544 size_t len;
545 int error;
546
547 if (!git_object__strict_input_validation)
548 return true;
549
550 if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||
551 (error = git_odb_read_header(&len, &actual_type, odb, id)) < 0)
552 return false;
553
554 if (expected_type != GIT_OBJECT_ANY && expected_type != actual_type) {
555 git_error_set(GIT_ERROR_INVALID,
556 "the requested type does not match the type in the ODB");
557 return false;
558 }
559
560 return true;
561 }
562