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