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