/* * This file is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License, version 2, * as published by the Free Software Foundation. * * In addition to the permissions in the GNU General Public License, * the authors give you unlimited permission to link the compiled * version of this file into combinations with other programs, * and to distribute those combinations without any restriction * coming from the use of this file. (The General Public License * restrictions do apply in other respects; for example, they cover * modification of the file, and distribution when not linked into * a combined executable.) * * This file is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; see the file COPYING. If not, write to * the Free Software Foundation, 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include <stdarg.h> #include "git2/object.h" #include "common.h" #include "repository.h" #include "commit.h" #include "tree.h" #include "blob.h" #include "tag.h" static const int OBJECT_BASE_SIZE = 4096; static struct { const char *str; /* type name string */ int loose; /* valid loose object type flag */ size_t size; /* size in bytes of the object structure */ } git_objects_table[] = { /* 0 = GIT_OBJ__EXT1 */ { "", 0, 0}, /* 1 = GIT_OBJ_COMMIT */ { "commit", 1, sizeof(struct git_commit)}, /* 2 = GIT_OBJ_TREE */ { "tree", 1, sizeof(struct git_tree) }, /* 3 = GIT_OBJ_BLOB */ { "blob", 1, sizeof(struct git_blob) }, /* 4 = GIT_OBJ_TAG */ { "tag", 1, sizeof(struct git_tag) }, /* 5 = GIT_OBJ__EXT2 */ { "", 0, 0 }, /* 6 = GIT_OBJ_OFS_DELTA */ { "OFS_DELTA", 0, 0 }, /* 7 = GIT_OBJ_REF_DELTA */ { "REF_DELTA", 0, 0 } }; static int create_object(git_object **object_out, git_otype type) { git_object *object = NULL; assert(object_out); *object_out = NULL; switch (type) { case GIT_OBJ_COMMIT: case GIT_OBJ_TAG: case GIT_OBJ_BLOB: case GIT_OBJ_TREE: object = git__malloc(git_object__size(type)); if (object == NULL) return GIT_ENOMEM; memset(object, 0x0, git_object__size(type)); break; default: return git__throw(GIT_EINVALIDTYPE, "The given type is invalid"); } object->type = type; *object_out = object; return GIT_SUCCESS; } int git_object_lookup_prefix(git_object **object_out, git_repository *repo, const git_oid *id, unsigned int len, git_otype type) { git_object *object = NULL; git_odb_object *odb_obj; int error = GIT_SUCCESS; assert(repo && object_out && id); if (len < GIT_OID_MINPREFIXLEN) return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to lookup object. Prefix length is lower than %d.", GIT_OID_MINPREFIXLEN); if (len > GIT_OID_HEXSZ) len = GIT_OID_HEXSZ; if (len == GIT_OID_HEXSZ) { /* 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 */ object = git_cache_get(&repo->objects, id); if (object != NULL) { if (type != GIT_OBJ_ANY && type != object->type) return git__throw(GIT_EINVALIDTYPE, "Failed to lookup object. The given type does not match the type on the ODB"); *object_out = object; return GIT_SUCCESS; } /* 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, repo->db, id); } else { git_oid short_oid; /* We copy the first len*4 bits from id and fill the remaining with 0s */ memcpy(short_oid.id, id->id, (len + 1) / 2); if (len % 2) short_oid.id[len / 2] &= 0xF0; memset(short_oid.id + (len + 1) / 2, 0, (GIT_OID_HEXSZ - len) / 2); /* If len < GIT_OID_HEXSZ (a strict short oid was given), we have * 2 options : * - We always search in the cache first. If we find that short oid is * 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) * - We never explore the cache, go right to exploring the backends * We chose the latter : we explore directly the backends. */ error = git_odb_read_prefix(&odb_obj, repo->db, &short_oid, len); } if (error < GIT_SUCCESS) return git__rethrow(error, "Failed to lookup object"); if (type != GIT_OBJ_ANY && type != odb_obj->raw.type) { git_odb_object_close(odb_obj); return git__throw(GIT_EINVALIDTYPE, "Failed to lookup object. The given type does not match the type on the ODB"); } type = odb_obj->raw.type; if ((error = create_object(&object, type)) < GIT_SUCCESS) return git__rethrow(error, "Failed to lookup object"); /* Initialize parent object */ git_oid_cpy(&object->cached.oid, &odb_obj->cached.oid); object->repo = repo; switch (type) { case GIT_OBJ_COMMIT: error = git_commit__parse((git_commit *)object, odb_obj); break; case GIT_OBJ_TREE: error = git_tree__parse((git_tree *)object, odb_obj); break; case GIT_OBJ_TAG: error = git_tag__parse((git_tag *)object, odb_obj); break; case GIT_OBJ_BLOB: error = git_blob__parse((git_blob *)object, odb_obj); break; default: break; } git_odb_object_close(odb_obj); if (error < GIT_SUCCESS) { git_object__free(object); return git__rethrow(error, "Failed to lookup object"); } *object_out = git_cache_try_store(&repo->objects, object); return GIT_SUCCESS; } int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_otype type) { return git_object_lookup_prefix(object_out, repo, id, GIT_OID_HEXSZ, type); } void git_object__free(void *_obj) { git_object *object = (git_object *)_obj; assert(object); switch (object->type) { case GIT_OBJ_COMMIT: git_commit__free((git_commit *)object); break; case GIT_OBJ_TREE: git_tree__free((git_tree *)object); break; case GIT_OBJ_TAG: git_tag__free((git_tag *)object); break; case GIT_OBJ_BLOB: git_blob__free((git_blob *)object); break; default: free(object); break; } } void git_object_close(git_object *object) { if (object == NULL) return; git_cached_obj_decref((git_cached_obj *)object, git_object__free); } const git_oid *git_object_id(const git_object *obj) { assert(obj); return &obj->cached.oid; } git_otype git_object_type(const git_object *obj) { assert(obj); return obj->type; } git_repository *git_object_owner(const git_object *obj) { assert(obj); return obj->repo; } const char *git_object_type2string(git_otype type) { if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table)) return ""; return git_objects_table[type].str; } git_otype git_object_string2type(const char *str) { size_t i; if (!str || !*str) return GIT_OBJ_BAD; for (i = 0; i < ARRAY_SIZE(git_objects_table); i++) if (!strcmp(str, git_objects_table[i].str)) return (git_otype)i; return GIT_OBJ_BAD; } int git_object_typeisloose(git_otype type) { if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table)) return 0; return git_objects_table[type].loose; } size_t git_object__size(git_otype type) { if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table)) return 0; return git_objects_table[type].size; }