From 1e6771e5046232e448e2dde4f0fee1752c9e1d04 Mon Sep 17 00:00:00 2001 From: Martin Ågren Date: Thu, 31 Dec 2020 12:56:20 +0100 Subject: object-name.c: rename from sha1-name.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Generalize the last remnants of "sha" and "sha1" in this file and rename it to reflect that we're not just able to handle SHA-1 these days. We need to update one test to check for an updated error string. Signed-off-by: Martin Ågren Reviewed-by: Derrick Stolee Signed-off-by: Junio C Hamano --- Makefile | 2 +- list-objects-filter.c | 2 +- object-name.c | 1954 +++++++++++++++++++++++++++++++++++ sha1-name.c | 1954 ----------------------------------- t/t1512-rev-parse-disambiguation.sh | 2 +- 5 files changed, 1957 insertions(+), 1957 deletions(-) create mode 100644 object-name.c delete mode 100644 sha1-name.c diff --git a/Makefile b/Makefile index 7b64106930..8bb1163f70 100644 --- a/Makefile +++ b/Makefile @@ -937,6 +937,7 @@ LIB_OBJS += notes-cache.o LIB_OBJS += notes-merge.o LIB_OBJS += notes-utils.o LIB_OBJS += notes.o +LIB_OBJS += object-name.o LIB_OBJS += object.o LIB_OBJS += oid-array.o LIB_OBJS += oidmap.o @@ -995,7 +996,6 @@ LIB_OBJS += server-info.o LIB_OBJS += setup.o LIB_OBJS += sha1-file.o LIB_OBJS += sha1-lookup.o -LIB_OBJS += sha1-name.o LIB_OBJS += shallow.o LIB_OBJS += sideband.o LIB_OBJS += sigchain.o diff --git a/list-objects-filter.c b/list-objects-filter.c index 0a3ef3cab3..4ec0041cfb 100644 --- a/list-objects-filter.c +++ b/list-objects-filter.c @@ -21,7 +21,7 @@ * in the traversal (until we mark it SEEN). This is a way to * let us silently de-dup calls to show() in the caller. This * is subtly different from the "revision.h:SHOWN" and the - * "sha1-name.c:ONELINE_SEEN" bits. And also different from + * "object-name.c:ONELINE_SEEN" bits. And also different from * the non-de-dup usage in pack-bitmap.c */ #define FILTER_SHOWN_BUT_REVISIT (1<<21) diff --git a/object-name.c b/object-name.c new file mode 100644 index 0000000000..64202de60b --- /dev/null +++ b/object-name.c @@ -0,0 +1,1954 @@ +#include "cache.h" +#include "config.h" +#include "tag.h" +#include "commit.h" +#include "tree.h" +#include "blob.h" +#include "tree-walk.h" +#include "refs.h" +#include "remote.h" +#include "dir.h" +#include "oid-array.h" +#include "packfile.h" +#include "object-store.h" +#include "repository.h" +#include "submodule.h" +#include "midx.h" +#include "commit-reach.h" + +static int get_oid_oneline(struct repository *r, const char *, struct object_id *, struct commit_list *); + +typedef int (*disambiguate_hint_fn)(struct repository *, const struct object_id *, void *); + +struct disambiguate_state { + int len; /* length of prefix in hex chars */ + char hex_pfx[GIT_MAX_HEXSZ + 1]; + struct object_id bin_pfx; + + struct repository *repo; + disambiguate_hint_fn fn; + void *cb_data; + struct object_id candidate; + unsigned candidate_exists:1; + unsigned candidate_checked:1; + unsigned candidate_ok:1; + unsigned disambiguate_fn_used:1; + unsigned ambiguous:1; + unsigned always_call_fn:1; +}; + +static void update_candidates(struct disambiguate_state *ds, const struct object_id *current) +{ + if (ds->always_call_fn) { + ds->ambiguous = ds->fn(ds->repo, current, ds->cb_data) ? 1 : 0; + return; + } + if (!ds->candidate_exists) { + /* this is the first candidate */ + oidcpy(&ds->candidate, current); + ds->candidate_exists = 1; + return; + } else if (oideq(&ds->candidate, current)) { + /* the same as what we already have seen */ + return; + } + + if (!ds->fn) { + /* cannot disambiguate between ds->candidate and current */ + ds->ambiguous = 1; + return; + } + + if (!ds->candidate_checked) { + ds->candidate_ok = ds->fn(ds->repo, &ds->candidate, ds->cb_data); + ds->disambiguate_fn_used = 1; + ds->candidate_checked = 1; + } + + if (!ds->candidate_ok) { + /* discard the candidate; we know it does not satisfy fn */ + oidcpy(&ds->candidate, current); + ds->candidate_checked = 0; + return; + } + + /* if we reach this point, we know ds->candidate satisfies fn */ + if (ds->fn(ds->repo, current, ds->cb_data)) { + /* + * if both current and candidate satisfy fn, we cannot + * disambiguate. + */ + ds->candidate_ok = 0; + ds->ambiguous = 1; + } + + /* otherwise, current can be discarded and candidate is still good */ +} + +static int match_hash(unsigned, const unsigned char *, const unsigned char *); + +static void find_short_object_filename(struct disambiguate_state *ds) +{ + struct object_directory *odb; + + for (odb = ds->repo->objects->odb; odb && !ds->ambiguous; odb = odb->next) { + int pos; + struct oid_array *loose_objects; + + loose_objects = odb_loose_cache(odb, &ds->bin_pfx); + pos = oid_array_lookup(loose_objects, &ds->bin_pfx); + if (pos < 0) + pos = -1 - pos; + while (!ds->ambiguous && pos < loose_objects->nr) { + const struct object_id *oid; + oid = loose_objects->oid + pos; + if (!match_hash(ds->len, ds->bin_pfx.hash, oid->hash)) + break; + update_candidates(ds, oid); + pos++; + } + } +} + +static int match_hash(unsigned len, const unsigned char *a, const unsigned char *b) +{ + do { + if (*a != *b) + return 0; + a++; + b++; + len -= 2; + } while (len > 1); + if (len) + if ((*a ^ *b) & 0xf0) + return 0; + return 1; +} + +static void unique_in_midx(struct multi_pack_index *m, + struct disambiguate_state *ds) +{ + uint32_t num, i, first = 0; + const struct object_id *current = NULL; + num = m->num_objects; + + if (!num) + return; + + bsearch_midx(&ds->bin_pfx, m, &first); + + /* + * At this point, "first" is the location of the lowest object + * with an object name that could match "bin_pfx". See if we have + * 0, 1 or more objects that actually match(es). + */ + for (i = first; i < num && !ds->ambiguous; i++) { + struct object_id oid; + current = nth_midxed_object_oid(&oid, m, i); + if (!match_hash(ds->len, ds->bin_pfx.hash, current->hash)) + break; + update_candidates(ds, current); + } +} + +static void unique_in_pack(struct packed_git *p, + struct disambiguate_state *ds) +{ + uint32_t num, i, first = 0; + + if (p->multi_pack_index) + return; + + if (open_pack_index(p) || !p->num_objects) + return; + + num = p->num_objects; + bsearch_pack(&ds->bin_pfx, p, &first); + + /* + * At this point, "first" is the location of the lowest object + * with an object name that could match "bin_pfx". See if we have + * 0, 1 or more objects that actually match(es). + */ + for (i = first; i < num && !ds->ambiguous; i++) { + struct object_id oid; + nth_packed_object_id(&oid, p, i); + if (!match_hash(ds->len, ds->bin_pfx.hash, oid.hash)) + break; + update_candidates(ds, &oid); + } +} + +static void find_short_packed_object(struct disambiguate_state *ds) +{ + struct multi_pack_index *m; + struct packed_git *p; + + for (m = get_multi_pack_index(ds->repo); m && !ds->ambiguous; + m = m->next) + unique_in_midx(m, ds); + for (p = get_packed_git(ds->repo); p && !ds->ambiguous; + p = p->next) + unique_in_pack(p, ds); +} + +static int finish_object_disambiguation(struct disambiguate_state *ds, + struct object_id *oid) +{ + if (ds->ambiguous) + return SHORT_NAME_AMBIGUOUS; + + if (!ds->candidate_exists) + return MISSING_OBJECT; + + if (!ds->candidate_checked) + /* + * If this is the only candidate, there is no point + * calling the disambiguation hint callback. + * + * On the other hand, if the current candidate + * replaced an earlier candidate that did _not_ pass + * the disambiguation hint callback, then we do have + * more than one objects that match the short name + * given, so we should make sure this one matches; + * otherwise, if we discovered this one and the one + * that we previously discarded in the reverse order, + * we would end up showing different results in the + * same repository! + */ + ds->candidate_ok = (!ds->disambiguate_fn_used || + ds->fn(ds->repo, &ds->candidate, ds->cb_data)); + + if (!ds->candidate_ok) + return SHORT_NAME_AMBIGUOUS; + + oidcpy(oid, &ds->candidate); + return 0; +} + +static int disambiguate_commit_only(struct repository *r, + const struct object_id *oid, + void *cb_data_unused) +{ + int kind = oid_object_info(r, oid, NULL); + return kind == OBJ_COMMIT; +} + +static int disambiguate_committish_only(struct repository *r, + const struct object_id *oid, + void *cb_data_unused) +{ + struct object *obj; + int kind; + + kind = oid_object_info(r, oid, NULL); + if (kind == OBJ_COMMIT) + return 1; + if (kind != OBJ_TAG) + return 0; + + /* We need to do this the hard way... */ + obj = deref_tag(r, parse_object(r, oid), NULL, 0); + if (obj && obj->type == OBJ_COMMIT) + return 1; + return 0; +} + +static int disambiguate_tree_only(struct repository *r, + const struct object_id *oid, + void *cb_data_unused) +{ + int kind = oid_object_info(r, oid, NULL); + return kind == OBJ_TREE; +} + +static int disambiguate_treeish_only(struct repository *r, + const struct object_id *oid, + void *cb_data_unused) +{ + struct object *obj; + int kind; + + kind = oid_object_info(r, oid, NULL); + if (kind == OBJ_TREE || kind == OBJ_COMMIT) + return 1; + if (kind != OBJ_TAG) + return 0; + + /* We need to do this the hard way... */ + obj = deref_tag(r, parse_object(r, oid), NULL, 0); + if (obj && (obj->type == OBJ_TREE || obj->type == OBJ_COMMIT)) + return 1; + return 0; +} + +static int disambiguate_blob_only(struct repository *r, + const struct object_id *oid, + void *cb_data_unused) +{ + int kind = oid_object_info(r, oid, NULL); + return kind == OBJ_BLOB; +} + +static disambiguate_hint_fn default_disambiguate_hint; + +int set_disambiguate_hint_config(const char *var, const char *value) +{ + static const struct { + const char *name; + disambiguate_hint_fn fn; + } hints[] = { + { "none", NULL }, + { "commit", disambiguate_commit_only }, + { "committish", disambiguate_committish_only }, + { "tree", disambiguate_tree_only }, + { "treeish", disambiguate_treeish_only }, + { "blob", disambiguate_blob_only } + }; + int i; + + if (!value) + return config_error_nonbool(var); + + for (i = 0; i < ARRAY_SIZE(hints); i++) { + if (!strcasecmp(value, hints[i].name)) { + default_disambiguate_hint = hints[i].fn; + return 0; + } + } + + return error("unknown hint type for '%s': %s", var, value); +} + +static int init_object_disambiguation(struct repository *r, + const char *name, int len, + struct disambiguate_state *ds) +{ + int i; + + if (len < MINIMUM_ABBREV || len > the_hash_algo->hexsz) + return -1; + + memset(ds, 0, sizeof(*ds)); + + for (i = 0; i < len ;i++) { + unsigned char c = name[i]; + unsigned char val; + if (c >= '0' && c <= '9') + val = c - '0'; + else if (c >= 'a' && c <= 'f') + val = c - 'a' + 10; + else if (c >= 'A' && c <='F') { + val = c - 'A' + 10; + c -= 'A' - 'a'; + } + else + return -1; + ds->hex_pfx[i] = c; + if (!(i & 1)) + val <<= 4; + ds->bin_pfx.hash[i >> 1] |= val; + } + + ds->len = len; + ds->hex_pfx[len] = '\0'; + ds->repo = r; + prepare_alt_odb(r); + return 0; +} + +static int show_ambiguous_object(const struct object_id *oid, void *data) +{ + const struct disambiguate_state *ds = data; + struct strbuf desc = STRBUF_INIT; + int type; + + if (ds->fn && !ds->fn(ds->repo, oid, ds->cb_data)) + return 0; + + type = oid_object_info(ds->repo, oid, NULL); + if (type == OBJ_COMMIT) { + struct commit *commit = lookup_commit(ds->repo, oid); + if (commit) { + struct pretty_print_context pp = {0}; + pp.date_mode.type = DATE_SHORT; + format_commit_message(commit, " %ad - %s", &desc, &pp); + } + } else if (type == OBJ_TAG) { + struct tag *tag = lookup_tag(ds->repo, oid); + if (!parse_tag(tag) && tag->tag) + strbuf_addf(&desc, " %s", tag->tag); + } + + advise(" %s %s%s", + repo_find_unique_abbrev(ds->repo, oid, DEFAULT_ABBREV), + type_name(type) ? type_name(type) : "unknown type", + desc.buf); + + strbuf_release(&desc); + return 0; +} + +static int collect_ambiguous(const struct object_id *oid, void *data) +{ + oid_array_append(data, oid); + return 0; +} + +static int repo_collect_ambiguous(struct repository *r, + const struct object_id *oid, + void *data) +{ + return collect_ambiguous(oid, data); +} + +static int sort_ambiguous(const void *a, const void *b, void *ctx) +{ + struct repository *sort_ambiguous_repo = ctx; + int a_type = oid_object_info(sort_ambiguous_repo, a, NULL); + int b_type = oid_object_info(sort_ambiguous_repo, b, NULL); + int a_type_sort; + int b_type_sort; + + /* + * Sorts by hash within the same object type, just as + * oid_array_for_each_unique() would do. + */ + if (a_type == b_type) + return oidcmp(a, b); + + /* + * Between object types show tags, then commits, and finally + * trees and blobs. + * + * The object_type enum is commit, tree, blob, tag, but we + * want tag, commit, tree blob. Cleverly (perhaps too + * cleverly) do that with modulus, since the enum assigns 1 to + * commit, so tag becomes 0. + */ + a_type_sort = a_type % 4; + b_type_sort = b_type % 4; + return a_type_sort > b_type_sort ? 1 : -1; +} + +static void sort_ambiguous_oid_array(struct repository *r, struct oid_array *a) +{ + QSORT_S(a->oid, a->nr, sort_ambiguous, r); +} + +static enum get_oid_result get_short_oid(struct repository *r, + const char *name, int len, + struct object_id *oid, + unsigned flags) +{ + int status; + struct disambiguate_state ds; + int quietly = !!(flags & GET_OID_QUIETLY); + + if (init_object_disambiguation(r, name, len, &ds) < 0) + return -1; + + if (HAS_MULTI_BITS(flags & GET_OID_DISAMBIGUATORS)) + BUG("multiple get_short_oid disambiguator flags"); + + if (flags & GET_OID_COMMIT) + ds.fn = disambiguate_commit_only; + else if (flags & GET_OID_COMMITTISH) + ds.fn = disambiguate_committish_only; + else if (flags & GET_OID_TREE) + ds.fn = disambiguate_tree_only; + else if (flags & GET_OID_TREEISH) + ds.fn = disambiguate_treeish_only; + else if (flags & GET_OID_BLOB) + ds.fn = disambiguate_blob_only; + else + ds.fn = default_disambiguate_hint; + + find_short_object_filename(&ds); + find_short_packed_object(&ds); + status = finish_object_disambiguation(&ds, oid); + + /* + * If we didn't find it, do the usual reprepare() slow-path, + * since the object may have recently been added to the repository + * or migrated from loose to packed. + */ + if (status == MISSING_OBJECT) { + reprepare_packed_git(r); + find_short_object_filename(&ds); + find_short_packed_object(&ds); + status = finish_object_disambiguation(&ds, oid); + } + + if (!quietly && (status == SHORT_NAME_AMBIGUOUS)) { + struct oid_array collect = OID_ARRAY_INIT; + + error(_("short object ID %s is ambiguous"), ds.hex_pfx); + + /* + * We may still have ambiguity if we simply saw a series of + * candidates that did not satisfy our hint function. In + * that case, we still want to show them, so disable the hint + * function entirely. + */ + if (!ds.ambiguous) + ds.fn = NULL; + + advise(_("The candidates are:")); + repo_for_each_abbrev(r, ds.hex_pfx, collect_ambiguous, &collect); + sort_ambiguous_oid_array(r, &collect); + + if (oid_array_for_each(&collect, show_ambiguous_object, &ds)) + BUG("show_ambiguous_object shouldn't return non-zero"); + oid_array_clear(&collect); + } + + return status; +} + +int repo_for_each_abbrev(struct repository *r, const char *prefix, + each_abbrev_fn fn, void *cb_data) +{ + struct oid_array collect = OID_ARRAY_INIT; + struct disambiguate_state ds; + int ret; + + if (init_object_disambiguation(r, prefix, strlen(prefix), &ds) < 0) + return -1; + + ds.always_call_fn = 1; + ds.fn = repo_collect_ambiguous; + ds.cb_data = &collect; + find_short_object_filename(&ds); + find_short_packed_object(&ds); + + ret = oid_array_for_each_unique(&collect, fn, cb_data); + oid_array_clear(&collect); + return ret; +} + +/* + * Return the slot of the most-significant bit set in "val". There are various + * ways to do this quickly with fls() or __builtin_clzl(), but speed is + * probably not a big deal here. + */ +static unsigned msb(unsigned long val) +{ + unsigned r = 0; + while (val >>= 1) + r++; + return r; +} + +struct min_abbrev_data { + unsigned int init_len; + unsigned int cur_len; + char *hex; + struct repository *repo; + const struct object_id *oid; +}; + +static inline char get_hex_char_from_oid(const struct object_id *oid, + unsigned int pos) +{ + static const char hex[] = "0123456789abcdef"; + + if ((pos & 1) == 0) + return hex[oid->hash[pos >> 1] >> 4]; + else + return hex[oid->hash[pos >> 1] & 0xf]; +} + +static int extend_abbrev_len(const struct object_id *oid, void *cb_data) +{ + struct min_abbrev_data *mad = cb_data; + + unsigned int i = mad->init_len; + while (mad->hex[i] && mad->hex[i] == get_hex_char_from_oid(oid, i)) + i++; + + if (i < GIT_MAX_RAWSZ && i >= mad->cur_len) + mad->cur_len = i + 1; + + return 0; +} + +static int repo_extend_abbrev_len(struct repository *r, + const struct object_id *oid, + void *cb_data) +{ + return extend_abbrev_len(oid, cb_data); +} + +static void find_abbrev_len_for_midx(struct multi_pack_index *m, + struct min_abbrev_data *mad) +{ + int match = 0; + uint32_t num, first = 0; + struct object_id oid; + const struct object_id *mad_oid; + + if (!m->num_objects) + return; + + num = m->num_objects; + mad_oid = mad->oid; + match = bsearch_midx(mad_oid, m, &first); + + /* + * first is now the position in the packfile where we would insert + * mad->hash if it does not exist (or the position of mad->hash if + * it does exist). Hence, we consider a maximum of two objects + * nearby for the abbreviation length. + */ + mad->init_len = 0; + if (!match) { + if (nth_midxed_object_oid(&oid, m, first)) + extend_abbrev_len(&oid, mad); + } else if (first < num - 1) { + if (nth_midxed_object_oid(&oid, m, first + 1)) + extend_abbrev_len(&oid, mad); + } + if (first > 0) { + if (nth_midxed_object_oid(&oid, m, first - 1)) + extend_abbrev_len(&oid, mad); + } + mad->init_len = mad->cur_len; +} + +static void find_abbrev_len_for_pack(struct packed_git *p, + struct min_abbrev_data *mad) +{ + int match = 0; + uint32_t num, first = 0; + struct object_id oid; + const struct object_id *mad_oid; + + if (p->multi_pack_index) + return; + + if (open_pack_index(p) || !p->num_objects) + return; + + num = p->num_objects; + mad_oid = mad->oid; + match = bsearch_pack(mad_oid, p, &first); + + /* + * first is now the position in the packfile where we would insert + * mad->hash if it does not exist (or the position of mad->hash if + * it does exist). Hence, we consider a maximum of two objects + * nearby for the abbreviation length. + */ + mad->init_len = 0; + if (!match) { + if (!nth_packed_object_id(&oid, p, first)) + extend_abbrev_len(&oid, mad); + } else if (first < num - 1) { + if (!nth_packed_object_id(&oid, p, first + 1)) + extend_abbrev_len(&oid, mad); + } + if (first > 0) { + if (!nth_packed_object_id(&oid, p, first - 1)) + extend_abbrev_len(&oid, mad); + } + mad->init_len = mad->cur_len; +} + +static void find_abbrev_len_packed(struct min_abbrev_data *mad) +{ + struct multi_pack_index *m; + struct packed_git *p; + + for (m = get_multi_pack_index(mad->repo); m; m = m->next) + find_abbrev_len_for_midx(m, mad); + for (p = get_packed_git(mad->repo); p; p = p->next) + find_abbrev_len_for_pack(p, mad); +} + +int repo_find_unique_abbrev_r(struct repository *r, char *hex, + const struct object_id *oid, int len) +{ + struct disambiguate_state ds; + struct min_abbrev_data mad; + struct object_id oid_ret; + const unsigned hexsz = r->hash_algo->hexsz; + + if (len < 0) { + unsigned long count = repo_approximate_object_count(r); + /* + * Add one because the MSB only tells us the highest bit set, + * not including the value of all the _other_ bits (so "15" + * is only one off of 2^4, but the MSB is the 3rd bit. + */ + len = msb(count) + 1; + /* + * We now know we have on the order of 2^len objects, which + * expects a collision at 2^(len/2). But we also care about hex + * chars, not bits, and there are 4 bits per hex. So all + * together we need to divide by 2 and round up. + */ + len = DIV_ROUND_UP(len, 2); + /* + * For very small repos, we stick with our regular fallback. + */ + if (len < FALLBACK_DEFAULT_ABBREV) + len = FALLBACK_DEFAULT_ABBREV; + } + + oid_to_hex_r(hex, oid); + if (len == hexsz || !len) + return hexsz; + + mad.repo = r; + mad.init_len = len; + mad.cur_len = len; + mad.hex = hex; + mad.oid = oid; + + find_abbrev_len_packed(&mad); + + if (init_object_disambiguation(r, hex, mad.cur_len, &ds) < 0) + return -1; + + ds.fn = repo_extend_abbrev_len; + ds.always_call_fn = 1; + ds.cb_data = (void *)&mad; + + find_short_object_filename(&ds); + (void)finish_object_disambiguation(&ds, &oid_ret); + + hex[mad.cur_len] = 0; + return mad.cur_len; +} + +const char *repo_find_unique_abbrev(struct repository *r, + const struct object_id *oid, + int len) +{ + static int bufno; + static char hexbuffer[4][GIT_MAX_HEXSZ + 1]; + char *hex = hexbuffer[bufno]; + bufno = (bufno + 1) % ARRAY_SIZE(hexbuffer); + repo_find_unique_abbrev_r(r, hex, oid, len); + return hex; +} + +static int ambiguous_path(const char *path, int len) +{ + int slash = 1; + int cnt; + + for (cnt = 0; cnt < len; cnt++) { + switch (*path++) { + case '\0': + break; + case '/': + if (slash) + break; + slash = 1; + continue; + case '.': + continue; + default: + slash = 0; + continue; + } + break; + } + return slash; +} + +static inline int at_mark(const char *string, int len, + const char **suffix, int nr) +{ + int i; + + for (i = 0; i < nr; i++) { + int suffix_len = strlen(suffix[i]); + if (suffix_len <= len + && !strncasecmp(string, suffix[i], suffix_len)) + return suffix_len; + } + return 0; +} + +static inline int upstream_mark(const char *string, int len) +{ + const char *suffix[] = { "@{upstream}", "@{u}" }; + return at_mark(string, len, suffix, ARRAY_SIZE(suffix)); +} + +static inline int push_mark(const char *string, int len) +{ + const char *suffix[] = { "@{push}" }; + return at_mark(string, len, suffix, ARRAY_SIZE(suffix)); +} + +static enum get_oid_result get_oid_1(struct repository *r, const char *name, int len, struct object_id *oid, unsigned lookup_flags); +static int interpret_nth_prior_checkout(struct repository *r, const char *name, int namelen, struct strbuf *buf); + +static int get_oid_basic(struct repository *r, const char *str, int len, + struct object_id *oid, unsigned int flags) +{ + static const char *warn_msg = "refname '%.*s' is ambiguous."; + static const char *object_name_msg = N_( + "Git normally never creates a ref that ends with 40 hex characters\n" + "because it will be ignored when you just specify 40-hex. These refs\n" + "may be created by mistake. For example,\n" + "\n" + " git switch -c $br $(git rev-parse ...)\n" + "\n" + "where \"$br\" is somehow empty and a 40-hex ref is created. Please\n" + "examine these refs and maybe delete them. Turn this message off by\n" + "running \"git config advice.objectNameWarning false\""); + struct object_id tmp_oid; + char *real_ref = NULL; + int refs_found = 0; + int at, reflog_len, nth_prior = 0; + + if (len == r->hash_algo->hexsz && !get_oid_hex(str, oid)) { + if (warn_ambiguous_refs && warn_on_object_refname_ambiguity) { + refs_found = repo_dwim_ref(r, str, len, &tmp_oid, &real_ref, 0); + if (refs_found > 0) { + warning(warn_msg, len, str); + if (advice_object_name_warning) + fprintf(stderr, "%s\n", _(object_name_msg)); + } + free(real_ref); + } + return 0; + } + + /* basic@{time or number or -number} format to query ref-log */ + reflog_len = at = 0; + if (len && str[len-1] == '}') { + for (at = len-4; at >= 0; at--) { + if (str[at] == '@' && str[at+1] == '{') { + if (str[at+2] == '-') { + if (at != 0) + /* @{-N} not at start */ + return -1; + nth_prior = 1; + continue; + } + if (!upstream_mark(str + at, len - at) && + !push_mark(str + at, len - at)) { + reflog_len = (len-1) - (at+2); + len = at; + } + break; + } + } + } + + /* Accept only unambiguous ref paths. */ + if (len && ambiguous_path(str, len)) + return -1; + + if (nth_prior) { + struct strbuf buf = STRBUF_INIT; + int detached; + + if (interpret_nth_prior_checkout(r, str, len, &buf) > 0) { + detached = (buf.len == r->hash_algo->hexsz && !get_oid_hex(buf.buf, oid)); + strbuf_release(&buf); + if (detached) + return 0; + } + } + + if (!len && reflog_len) + /* allow "@{...}" to mean the current branch reflog */ + refs_found = repo_dwim_ref(r, "HEAD", 4, oid, &real_ref, 0); + else if (reflog_len) + refs_found = repo_dwim_log(r, str, len, oid, &real_ref); + else + refs_found = repo_dwim_ref(r, str, len, oid, &real_ref, 0); + + if (!refs_found) + return -1; + + if (warn_ambiguous_refs && !(flags & GET_OID_QUIETLY) && + (refs_found > 1 || + !get_short_oid(r, str, len, &tmp_oid, GET_OID_QUIETLY))) + warning(warn_msg, len, str); + + if (reflog_len) { + int nth, i; + timestamp_t at_time; + timestamp_t co_time; + int co_tz, co_cnt; + + /* Is it asking for N-th entry, or approxidate? */ + for (i = nth = 0; 0 <= nth && i < reflog_len; i++) { + char ch = str[at+2+i]; + if ('0' <= ch && ch <= '9') + nth = nth * 10 + ch - '0'; + else + nth = -1; + } + if (100000000 <= nth) { + at_time = nth; + nth = -1; + } else if (0 <= nth) + at_time = 0; + else { + int errors = 0; + char *tmp = xstrndup(str + at + 2, reflog_len); + at_time = approxidate_careful(tmp, &errors); + free(tmp); + if (errors) { + free(real_ref); + return -1; + } + } + if (read_ref_at(get_main_ref_store(r), + real_ref, flags, at_time, nth, oid, NULL, + &co_time, &co_tz, &co_cnt)) { + if (!len) { + if (!skip_prefix(real_ref, "refs/heads/", &str)) + str = "HEAD"; + len = strlen(str); + } + if (at_time) { + if (!(flags & GET_OID_QUIETLY)) { + warning(_("log for '%.*s' only goes back to %s"), + len, str, + show_date(co_time, co_tz, DATE_MODE(RFC2822))); + } + } else { + if (flags & GET_OID_QUIETLY) { + exit(128); + } + die(_("log for '%.*s' only has %d entries"), + len, str, co_cnt); + } + } + } + + free(real_ref); + return 0; +} + +static enum get_oid_result get_parent(struct repository *r, + const char *name, int len, + struct object_id *result, int idx) +{ + struct object_id oid; + enum get_oid_result ret = get_oid_1(r, name, len, &oid, + GET_OID_COMMITTISH); + struct commit *commit; + struct commit_list *p; + + if (ret) + return ret; + commit = lookup_commit_reference(r, &oid); + if (parse_commit(commit)) + return MISSING_OBJECT; + if (!idx) { + oidcpy(result, &commit->object.oid); + return FOUND; + } + p = commit->parents; + while (p) { + if (!--idx) { + oidcpy(result, &p->item->object.oid); + return FOUND; + } + p = p->next; + } + return MISSING_OBJECT; +} + +static enum get_oid_result get_nth_ancestor(struct repository *r, + const char *name, int len, + struct object_id *result, + int generation) +{ + struct object_id oid; + struct commit *commit; + int ret; + + ret = get_oid_1(r, name, len, &oid, GET_OID_COMMITTISH); + if (ret) + return ret; + commit = lookup_commit_reference(r, &oid); + if (!commit) + return MISSING_OBJECT; + + while (generation--) { + if (parse_commit(commit) || !commit->parents) + return MISSING_OBJECT; + commit = commit->parents->item; + } + oidcpy(result, &commit->object.oid); + return FOUND; +} + +struct object *repo_peel_to_type(struct repository *r, const char *name, int namelen, + struct object *o, enum object_type expected_type) +{ + if (name && !namelen) + namelen = strlen(name); + while (1) { + if (!o || (!o->parsed && !parse_object(r, &o->oid))) + return NULL; + if (expected_type == OBJ_ANY || o->type == expected_type) + return o; + if (o->type == OBJ_TAG) + o = ((struct tag*) o)->tagged; + else if (o->type == OBJ_COMMIT) + o = &(repo_get_commit_tree(r, ((struct commit *)o))->object); + else { + if (name) + error("%.*s: expected %s type, but the object " + "dereferences to %s type", + namelen, name, type_name(expected_type), + type_name(o->type)); + return NULL; + } + } +} + +static int peel_onion(struct repository *r, const char *name, int len, + struct object_id *oid, unsigned lookup_flags) +{ + struct object_id outer; + const char *sp; + unsigned int expected_type = 0; + struct object *o; + + /* + * "ref^{type}" dereferences ref repeatedly until you cannot + * dereference anymore, or you get an object of given type, + * whichever comes first. "ref^{}" means just dereference + * tags until you get a non-tag. "ref^0" is a shorthand for + * "ref^{commit}". "commit^{tree}" could be used to find the + * top-level tree of the given commit. + */ + if (len < 4 || name[len-1] != '}') + return -1; + + for (sp = name + len - 1; name <= sp; sp--) { + int ch = *sp; + if (ch == '{' && name < sp && sp[-1] == '^') + break; + } + if (sp <= name) + return -1; + + sp++; /* beginning of type name, or closing brace for empty */ + if (starts_with(sp, "commit}")) + expected_type = OBJ_COMMIT; + else if (starts_with(sp, "tag}")) + expected_type = OBJ_TAG; + else if (starts_with(sp, "tree}")) + expected_type = OBJ_TREE; + else if (starts_with(sp, "blob}")) + expected_type = OBJ_BLOB; + else if (starts_with(sp, "object}")) + expected_type = OBJ_ANY; + else if (sp[0] == '}') + expected_type = OBJ_NONE; + else if (sp[0] == '/') + expected_type = OBJ_COMMIT; + else + return -1; + + lookup_flags &= ~GET_OID_DISAMBIGUATORS; + if (expected_type == OBJ_COMMIT) + lookup_flags |= GET_OID_COMMITTISH; + else if (expected_type == OBJ_TREE) + lookup_flags |= GET_OID_TREEISH; + + if (get_oid_1(r, name, sp - name - 2, &outer, lookup_flags)) + return -1; + + o = parse_object(r, &outer); + if (!o) + return -1; + if (!expected_type) { + o = deref_tag(r, o, name, sp - name - 2); + if (!o || (!o->parsed && !parse_object(r, &o->oid))) + return -1; + oidcpy(oid, &o->oid); + return 0; + } + + /* + * At this point, the syntax look correct, so + * if we do not get the needed object, we should + * barf. + */ + o = repo_peel_to_type(r, name, len, o, expected_type); + if (!o) + return -1; + + oidcpy(oid, &o->oid); + if (sp[0] == '/') { + /* "$commit^{/foo}" */ + char *prefix; + int ret; + struct commit_list *list = NULL; + + /* + * $commit^{/}. Some regex implementation may reject. + * We don't need regex anyway. '' pattern always matches. + */ + if (sp[1] == '}') + return 0; + + prefix = xstrndup(sp + 1, name + len - 1 - (sp + 1)); + commit_list_insert((struct commit *)o, &list); + ret = get_oid_oneline(r, prefix, oid, list); + free(prefix); + return ret; + } + return 0; +} + +static int get_describe_name(struct repository *r, + const char *name, int len, + struct object_id *oid) +{ + const char *cp; + unsigned flags = GET_OID_QUIETLY | GET_OID_COMMIT; + + for (cp = name + len - 1; name + 2 <= cp; cp--) { + char ch = *cp; + if (!isxdigit(ch)) { + /* We must be looking at g in "SOMETHING-g" + * for it to be describe output. + */ + if (ch == 'g' && cp[-1] == '-') { + cp++; + len -= cp - name; + return get_short_oid(r, + cp, len, oid, flags); + } + } + } + return -1; +} + +static enum get_oid_result get_oid_1(struct repository *r, + const char *name, int len, + struct object_id *oid, + unsigned lookup_flags) +{ + int ret, has_suffix; + const char *cp; + + /* + * "name~3" is "name^^^", "name~" is "name~1", and "name^" is "name^1". + */ + has_suffix = 0; + for (cp = name + len - 1; name <= cp; cp--) { + int ch = *cp; + if ('0' <= ch && ch <= '9') + continue; + if (ch == '~' || ch == '^') + has_suffix = ch; + break; + } + + if (has_suffix) { + unsigned int num = 0; + int len1 = cp - name; + cp++; + while (cp < name + len) { + unsigned int digit = *cp++ - '0'; + if (unsigned_mult_overflows(num, 10)) + return MISSING_OBJECT; + num *= 10; + if (unsigned_add_overflows(num, digit)) + return MISSING_OBJECT; + num += digit; + } + if (!num && len1 == len - 1) + num = 1; + else if (num > INT_MAX) + return MISSING_OBJECT; + if (has_suffix == '^') + return get_parent(r, name, len1, oid, num); + /* else if (has_suffix == '~') -- goes without saying */ + return get_nth_ancestor(r, name, len1, oid, num); + } + + ret = peel_onion(r, name, len, oid, lookup_flags); + if (!ret) + return FOUND; + + ret = get_oid_basic(r, name, len, oid, lookup_flags); + if (!ret) + return FOUND; + + /* It could be describe output that is "SOMETHING-gXXXX" */ + ret = get_describe_name(r, name, len, oid); + if (!ret) + return FOUND; + + return get_short_oid(r, name, len, oid, lookup_flags); +} + +/* + * This interprets names like ':/Initial revision of "git"' by searching + * through history and returning the first commit whose message starts + * the given regular expression. + * + * For negative-matching, prefix the pattern-part with '!-', like: ':/!-WIP'. + * + * For a literal '!' character at the beginning of a pattern, you have to repeat + * that, like: ':/!!foo' + * + * For future extension, all other sequences beginning with ':/!' are reserved. + */ + +/* Remember to update object flag allocation in object.h */ +#define ONELINE_SEEN (1u<<20) + +struct handle_one_ref_cb { + struct repository *repo; + struct commit_list **list; +}; + +static int handle_one_ref(const char *path, const struct object_id *oid, + int flag, void *cb_data) +{ + struct handle_one_ref_cb *cb = cb_data; + struct commit_list **list = cb->list; + struct object *object = parse_object(cb->repo, oid); + if (!object) + return 0; + if (object->type == OBJ_TAG) { + object = deref_tag(cb->repo, object, path, + strlen(path)); + if (!object) + return 0; + } + if (object->type != OBJ_COMMIT) + return 0; + commit_list_insert((struct commit *)object, list); + return 0; +} + +static int get_oid_oneline(struct repository *r, + const char *prefix, struct object_id *oid, + struct commit_list *list) +{ + struct commit_list *backup = NULL, *l; + int found = 0; + int negative = 0; + regex_t regex; + + if (prefix[0] == '!') { + prefix++; + + if (prefix[0] == '-') { + prefix++; + negative = 1; + } else if (prefix[0] != '!') { + return -1; + } + } + + if (regcomp(®ex, prefix, REG_EXTENDED)) + return -1; + + for (l = list; l; l = l->next) { + l->item->object.flags |= ONELINE_SEEN; + commit_list_insert(l->item, &backup); + } + while (list) { + const char *p, *buf; + struct commit *commit; + int matches; + + commit = pop_most_recent_commit(&list, ONELINE_SEEN); + if (!parse_object(r, &commit->object.oid)) + continue; + buf = get_commit_buffer(commit, NULL); + p = strstr(buf, "\n\n"); + matches = negative ^ (p && !regexec(®ex, p + 2, 0, NULL, 0)); + unuse_commit_buffer(commit, buf); + + if (matches) { + oidcpy(oid, &commit->object.oid); + found = 1; + break; + } + } + regfree(®ex); + free_commit_list(list); + for (l = backup; l; l = l->next) + clear_commit_marks(l->item, ONELINE_SEEN); + free_commit_list(backup); + return found ? 0 : -1; +} + +struct grab_nth_branch_switch_cbdata { + int remaining; + struct strbuf *sb; +}; + +static int grab_nth_branch_switch(struct object_id *ooid, struct object_id *noid, + const char *email, timestamp_t timestamp, int tz, + const char *message, void *cb_data) +{ + struct grab_nth_branch_switch_cbdata *cb = cb_data; + const char *match = NULL, *target = NULL; + size_t len; + + if (skip_prefix(message, "checkout: moving from ", &match)) + target = strstr(match, " to "); + + if (!match || !target) + return 0; + if (--(cb->remaining) == 0) { + len = target - match; + strbuf_reset(cb->sb); + strbuf_add(cb->sb, match, len); + return 1; /* we are done */ + } + return 0; +} + +/* + * Parse @{-N} syntax, return the number of characters parsed + * if successful; otherwise signal an error with negative value. + */ +static int interpret_nth_prior_checkout(struct repository *r, + const char *name, int namelen, + struct strbuf *buf) +{ + long nth; + int retval; + struct grab_nth_branch_switch_cbdata cb; + const char *brace; + char *num_end; + + if (namelen < 4) + return -1; + if (name[0] != '@' || name[1] != '{' || name[2] != '-') + return -1; + brace = memchr(name, '}', namelen); + if (!brace) + return -1; + nth = strtol(name + 3, &num_end, 10); + if (num_end != brace) + return -1; + if (nth <= 0) + return -1; + cb.remaining = nth; + cb.sb = buf; + + retval = refs_for_each_reflog_ent_reverse(get_main_ref_store(r), + "HEAD", grab_nth_branch_switch, &cb); + if (0 < retval) { + retval = brace - name + 1; + } else + retval = 0; + + return retval; +} + +int repo_get_oid_mb(struct repository *r, + const char *name, + struct object_id *oid) +{ + struct commit *one, *two; + struct commit_list *mbs; + struct object_id oid_tmp; + const char *dots; + int st; + + dots = strstr(name, "..."); + if (!dots) + return repo_get_oid(r, name, oid); + if (dots == name) + st = repo_get_oid(r, "HEAD", &oid_tmp); + else { + struct strbuf sb; + strbuf_init(&sb, dots - name); + strbuf_add(&sb, name, dots - name); + st = repo_get_oid_committish(r, sb.buf, &oid_tmp); + strbuf_release(&sb); + } + if (st) + return st; + one = lookup_commit_reference_gently(r, &oid_tmp, 0); + if (!one) + return -1; + + if (repo_get_oid_committish(r, dots[3] ? (dots + 3) : "HEAD", &oid_tmp)) + return -1; + two = lookup_commit_reference_gently(r, &oid_tmp, 0); + if (!two) + return -1; + mbs = repo_get_merge_bases(r, one, two); + if (!mbs || mbs->next) + st = -1; + else { + st = 0; + oidcpy(oid, &mbs->item->object.oid); + } + free_commit_list(mbs); + return st; +} + +/* parse @something syntax, when 'something' is not {.*} */ +static int interpret_empty_at(const char *name, int namelen, int len, struct strbuf *buf) +{ + const char *next; + + if (len || name[1] == '{') + return -1; + + /* make sure it's a single @, or @@{.*}, not @foo */ + next = memchr(name + len + 1, '@', namelen - len - 1); + if (next && next[1] != '{') + return -1; + if (!next) + next = name + namelen; + if (next != name + 1) + return -1; + + strbuf_reset(buf); + strbuf_add(buf, "HEAD", 4); + return 1; +} + +static int reinterpret(struct repository *r, + const char *name, int namelen, int len, + struct strbuf *buf, unsigned allowed) +{ + /* we have extra data, which might need further processing */ + struct strbuf tmp = STRBUF_INIT; + int used = buf->len; + int ret; + struct interpret_branch_name_options options = { + .allowed = allowed + }; + + strbuf_add(buf, name + len, namelen - len); + ret = repo_interpret_branch_name(r, buf->buf, buf->len, &tmp, &options); + /* that data was not interpreted, remove our cruft */ + if (ret < 0) { + strbuf_setlen(buf, used); + return len; + } + strbuf_reset(buf); + strbuf_addbuf(buf, &tmp); + strbuf_release(&tmp); + /* tweak for size of {-N} versus expanded ref name */ + return ret - used + len; +} + +static void set_shortened_ref(struct repository *r, struct strbuf *buf, const char *ref) +{ + char *s = refs_shorten_unambiguous_ref(get_main_ref_store(r), ref, 0); + strbuf_reset(buf); + strbuf_addstr(buf, s); + free(s); +} + +static int branch_interpret_allowed(const char *refname, unsigned allowed) +{ + if (!allowed) + return 1; + + if ((allowed & INTERPRET_BRANCH_LOCAL) && + starts_with(refname, "refs/heads/")) + return 1; + if ((allowed & INTERPRET_BRANCH_REMOTE) && + starts_with(refname, "refs/remotes/")) + return 1; + + return 0; +} + +static int interpret_branch_mark(struct repository *r, + const char *name, int namelen, + int at, struct strbuf *buf, + int (*get_mark)(const char *, int), + const char *(*get_data)(struct branch *, + struct strbuf *), + const struct interpret_branch_name_options *options) +{ + int len; + struct branch *branch; + struct strbuf err = STRBUF_INIT; + const char *value; + + len = get_mark(name + at, namelen - at); + if (!len) + return -1; + + if (memchr(name, ':', at)) + return -1; + + if (at) { + char *name_str = xmemdupz(name, at); + branch = branch_get(name_str); + free(name_str); + } else + branch = branch_get(NULL); + + value = get_data(branch, &err); + if (!value) { + if (options->nonfatal_dangling_mark) { + strbuf_release(&err); + return -1; + } else { + die("%s", err.buf); + } + } + + if (!branch_interpret_allowed(value, options->allowed)) + return -1; + + set_shortened_ref(r, buf, value); + return len + at; +} + +int repo_interpret_branch_name(struct repository *r, + const char *name, int namelen, + struct strbuf *buf, + const struct interpret_branch_name_options *options) +{ + char *at; + const char *start; + int len; + + if (!namelen) + namelen = strlen(name); + + if (!options->allowed || (options->allowed & INTERPRET_BRANCH_LOCAL)) { + len = interpret_nth_prior_checkout(r, name, namelen, buf); + if (!len) { + return len; /* syntax Ok, not enough switches */ + } else if (len > 0) { + if (len == namelen) + return len; /* consumed all */ + else + return reinterpret(r, name, namelen, len, buf, + options->allowed); + } + } + + for (start = name; + (at = memchr(start, '@', namelen - (start - name))); + start = at + 1) { + + if (!options->allowed || (options->allowed & INTERPRET_BRANCH_HEAD)) { + len = interpret_empty_at(name, namelen, at - name, buf); + if (len > 0) + return reinterpret(r, name, namelen, len, buf, + options->allowed); + } + + len = interpret_branch_mark(r, name, namelen, at - name, buf, + upstream_mark, branch_get_upstream, + options); + if (len > 0) + return len; + + len = interpret_branch_mark(r, name, namelen, at - name, buf, + push_mark, branch_get_push, + options); + if (len > 0) + return len; + } + + return -1; +} + +void strbuf_branchname(struct strbuf *sb, const char *name, unsigned allowed) +{ + int len = strlen(name); + struct interpret_branch_name_options options = { + .allowed = allowed + }; + int used = interpret_branch_name(name, len, sb, &options); + + if (used < 0) + used = 0; + strbuf_add(sb, name + used, len - used); +} + +int strbuf_check_branch_ref(struct strbuf *sb, const char *name) +{ + if (startup_info->have_repository) + strbuf_branchname(sb, name, INTERPRET_BRANCH_LOCAL); + else + strbuf_addstr(sb, name); + + /* + * This splice must be done even if we end up rejecting the + * name; builtin/branch.c::copy_or_rename_branch() still wants + * to see what the name expanded to so that "branch -m" can be + * used as a tool to correct earlier mistakes. + */ + strbuf_splice(sb, 0, 0, "refs/heads/", 11); + + if (*name == '-' || + !strcmp(sb->buf, "refs/heads/HEAD")) + return -1; + + return check_refname_format(sb->buf, 0); +} + +/* + * This is like "get_oid_basic()", except it allows "object ID expressions", + * notably "xyz^" for "parent of xyz" + */ +int repo_get_oid(struct repository *r, const char *name, struct object_id *oid) +{ + struct object_context unused; + return get_oid_with_context(r, name, 0, oid, &unused); +} + +/* + * This returns a non-zero value if the string (built using printf + * format and the given arguments) is not a valid object. + */ +int get_oidf(struct object_id *oid, const char *fmt, ...) +{ + va_list ap; + int ret; + struct strbuf sb = STRBUF_INIT; + + va_start(ap, fmt); + strbuf_vaddf(&sb, fmt, ap); + va_end(ap); + + ret = get_oid(sb.buf, oid); + strbuf_release(&sb); + + return ret; +} + +/* + * Many callers know that the user meant to name a commit-ish by + * syntactical positions where the object name appears. Calling this + * function allows the machinery to disambiguate shorter-than-unique + * abbreviated object names between commit-ish and others. + * + * Note that this does NOT error out when the named object is not a + * commit-ish. It is merely to give a hint to the disambiguation + * machinery. + */ +int repo_get_oid_committish(struct repository *r, + const char *name, + struct object_id *oid) +{ + struct object_context unused; + return get_oid_with_context(r, name, GET_OID_COMMITTISH, + oid, &unused); +} + +int repo_get_oid_treeish(struct repository *r, + const char *name, + struct object_id *oid) +{ + struct object_context unused; + return get_oid_with_context(r, name, GET_OID_TREEISH, + oid, &unused); +} + +int repo_get_oid_commit(struct repository *r, + const char *name, + struct object_id *oid) +{ + struct object_context unused; + return get_oid_with_context(r, name, GET_OID_COMMIT, + oid, &unused); +} + +int repo_get_oid_tree(struct repository *r, + const char *name, + struct object_id *oid) +{ + struct object_context unused; + return get_oid_with_context(r, name, GET_OID_TREE, + oid, &unused); +} + +int repo_get_oid_blob(struct repository *r, + const char *name, + struct object_id *oid) +{ + struct object_context unused; + return get_oid_with_context(r, name, GET_OID_BLOB, + oid, &unused); +} + +/* Must be called only when object_name:filename doesn't exist. */ +static void diagnose_invalid_oid_path(struct repository *r, + const char *prefix, + const char *filename, + const struct object_id *tree_oid, + const char *object_name, + int object_name_len) +{ + struct object_id oid; + unsigned short mode; + + if (!prefix) + prefix = ""; + + if (file_exists(filename)) + die(_("path '%s' exists on disk, but not in '%.*s'"), + filename, object_name_len, object_name); + if (is_missing_file_error(errno)) { + char *fullname = xstrfmt("%s%s", prefix, filename); + + if (!get_tree_entry(r, tree_oid, fullname, &oid, &mode)) { + die(_("path '%s' exists, but not '%s'\n" + "hint: Did you mean '%.*s:%s' aka '%.*s:./%s'?"), + fullname, + filename, + object_name_len, object_name, + fullname, + object_name_len, object_name, + filename); + } + die(_("path '%s' does not exist in '%.*s'"), + filename, object_name_len, object_name); + } +} + +/* Must be called only when :stage:filename doesn't exist. */ +static void diagnose_invalid_index_path(struct repository *r, + int stage, + const char *prefix, + const char *filename) +{ + struct index_state *istate = r->index; + const struct cache_entry *ce; + int pos; + unsigned namelen = strlen(filename); + struct strbuf fullname = STRBUF_INIT; + + if (!prefix) + prefix = ""; + + /* Wrong stage number? */ + pos = index_name_pos(istate, filename, namelen); + if (pos < 0) + pos = -pos - 1; + if (pos < istate->cache_nr) { + ce = istate->cache[pos]; + if (ce_namelen(ce) == namelen && + !memcmp(ce->name, filename, namelen)) + die(_("path '%s' is in the index, but not at stage %d\n" + "hint: Did you mean ':%d:%s'?"), + filename, stage, + ce_stage(ce), filename); + } + + /* Confusion between relative and absolute filenames? */ + strbuf_addstr(&fullname, prefix); + strbuf_addstr(&fullname, filename); + pos = index_name_pos(istate, fullname.buf, fullname.len); + if (pos < 0) + pos = -pos - 1; + if (pos < istate->cache_nr) { + ce = istate->cache[pos]; + if (ce_namelen(ce) == fullname.len && + !memcmp(ce->name, fullname.buf, fullname.len)) + die(_("path '%s' is in the index, but not '%s'\n" + "hint: Did you mean ':%d:%s' aka ':%d:./%s'?"), + fullname.buf, filename, + ce_stage(ce), fullname.buf, + ce_stage(ce), filename); + } + + if (repo_file_exists(r, filename)) + die(_("path '%s' exists on disk, but not in the index"), filename); + if (is_missing_file_error(errno)) + die(_("path '%s' does not exist (neither on disk nor in the index)"), + filename); + + strbuf_release(&fullname); +} + + +static char *resolve_relative_path(struct repository *r, const char *rel) +{ + if (!starts_with(rel, "./") && !starts_with(rel, "../")) + return NULL; + + if (r != the_repository || !is_inside_work_tree()) + die(_("relative path syntax can't be used outside working tree")); + + /* die() inside prefix_path() if resolved path is outside worktree */ + return prefix_path(startup_info->prefix, + startup_info->prefix ? strlen(startup_info->prefix) : 0, + rel); +} + +static enum get_oid_result get_oid_with_context_1(struct repository *repo, + const char *name, + unsigned flags, + const char *prefix, + struct object_id *oid, + struct object_context *oc) +{ + int ret, bracket_depth; + int namelen = strlen(name); + const char *cp; + int only_to_die = flags & GET_OID_ONLY_TO_DIE; + + if (only_to_die) + flags |= GET_OID_QUIETLY; + + memset(oc, 0, sizeof(*oc)); + oc->mode = S_IFINVALID; + strbuf_init(&oc->symlink_path, 0); + ret = get_oid_1(repo, name, namelen, oid, flags); + if (!ret) + return ret; + /* + * tree:path --> object name of path in tree + * :path -> object name of absolute path in index + * :./path -> object name of path relative to cwd in index + * :[0-3]:path -> object name of path in index at stage + * :/foo -> recent commit matching foo + */ + if (name[0] == ':') { + int stage = 0; + const struct cache_entry *ce; + char *new_path = NULL; + int pos; + if (!only_to_die && namelen > 2 && name[1] == '/') { + struct handle_one_ref_cb cb; + struct commit_list *list = NULL; + + cb.repo = repo; + cb.list = &list; + refs_for_each_ref(get_main_ref_store(repo), handle_one_ref, &cb); + refs_head_ref(get_main_ref_store(repo), handle_one_ref, &cb); + commit_list_sort_by_date(&list); + return get_oid_oneline(repo, name + 2, oid, list); + } + if (namelen < 3 || + name[2] != ':' || + name[1] < '0' || '3' < name[1]) + cp = name + 1; + else { + stage = name[1] - '0'; + cp = name + 3; + } + new_path = resolve_relative_path(repo, cp); + if (!new_path) { + namelen = namelen - (cp - name); + } else { + cp = new_path; + namelen = strlen(cp); + } + + if (flags & GET_OID_RECORD_PATH) + oc->path = xstrdup(cp); + + if (!repo->index || !repo->index->cache) + repo_read_index(repo); + pos = index_name_pos(repo->index, cp, namelen); + if (pos < 0) + pos = -pos - 1; + while (pos < repo->index->cache_nr) { + ce = repo->index->cache[pos]; + if (ce_namelen(ce) != namelen || + memcmp(ce->name, cp, namelen)) + break; + if (ce_stage(ce) == stage) { + oidcpy(oid, &ce->oid); + oc->mode = ce->ce_mode; + free(new_path); + return 0; + } + pos++; + } + if (only_to_die && name[1] && name[1] != '/') + diagnose_invalid_index_path(repo, stage, prefix, cp); + free(new_path); + return -1; + } + for (cp = name, bracket_depth = 0; *cp; cp++) { + if (*cp == '{') + bracket_depth++; + else if (bracket_depth && *cp == '}') + bracket_depth--; + else if (!bracket_depth && *cp == ':') + break; + } + if (*cp == ':') { + struct object_id tree_oid; + int len = cp - name; + unsigned sub_flags = flags; + + sub_flags &= ~GET_OID_DISAMBIGUATORS; + sub_flags |= GET_OID_TREEISH; + + if (!get_oid_1(repo, name, len, &tree_oid, sub_flags)) { + const char *filename = cp+1; + char *new_filename = NULL; + + new_filename = resolve_relative_path(repo, filename); + if (new_filename) + filename = new_filename; + if (flags & GET_OID_FOLLOW_SYMLINKS) { + ret = get_tree_entry_follow_symlinks(repo, &tree_oid, + filename, oid, &oc->symlink_path, + &oc->mode); + } else { + ret = get_tree_entry(repo, &tree_oid, filename, oid, + &oc->mode); + if (ret && only_to_die) { + diagnose_invalid_oid_path(repo, prefix, + filename, + &tree_oid, + name, len); + } + } + if (flags & GET_OID_RECORD_PATH) + oc->path = xstrdup(filename); + + free(new_filename); + return ret; + } else { + if (only_to_die) + die(_("invalid object name '%.*s'."), len, name); + } + } + return ret; +} + +/* + * Call this function when you know "name" given by the end user must + * name an object but it doesn't; the function _may_ die with a better + * diagnostic message than "no such object 'name'", e.g. "Path 'doc' does not + * exist in 'HEAD'" when given "HEAD:doc", or it may return in which case + * you have a chance to diagnose the error further. + */ +void maybe_die_on_misspelt_object_name(struct repository *r, + const char *name, + const char *prefix) +{ + struct object_context oc; + struct object_id oid; + get_oid_with_context_1(r, name, GET_OID_ONLY_TO_DIE, + prefix, &oid, &oc); +} + +enum get_oid_result get_oid_with_context(struct repository *repo, + const char *str, + unsigned flags, + struct object_id *oid, + struct object_context *oc) +{ + if (flags & GET_OID_FOLLOW_SYMLINKS && flags & GET_OID_ONLY_TO_DIE) + BUG("incompatible flags for get_oid_with_context"); + return get_oid_with_context_1(repo, str, flags, NULL, oid, oc); +} diff --git a/sha1-name.c b/sha1-name.c deleted file mode 100644 index 0b23b86ceb..0000000000 --- a/sha1-name.c +++ /dev/null @@ -1,1954 +0,0 @@ -#include "cache.h" -#include "config.h" -#include "tag.h" -#include "commit.h" -#include "tree.h" -#include "blob.h" -#include "tree-walk.h" -#include "refs.h" -#include "remote.h" -#include "dir.h" -#include "oid-array.h" -#include "packfile.h" -#include "object-store.h" -#include "repository.h" -#include "submodule.h" -#include "midx.h" -#include "commit-reach.h" - -static int get_oid_oneline(struct repository *r, const char *, struct object_id *, struct commit_list *); - -typedef int (*disambiguate_hint_fn)(struct repository *, const struct object_id *, void *); - -struct disambiguate_state { - int len; /* length of prefix in hex chars */ - char hex_pfx[GIT_MAX_HEXSZ + 1]; - struct object_id bin_pfx; - - struct repository *repo; - disambiguate_hint_fn fn; - void *cb_data; - struct object_id candidate; - unsigned candidate_exists:1; - unsigned candidate_checked:1; - unsigned candidate_ok:1; - unsigned disambiguate_fn_used:1; - unsigned ambiguous:1; - unsigned always_call_fn:1; -}; - -static void update_candidates(struct disambiguate_state *ds, const struct object_id *current) -{ - if (ds->always_call_fn) { - ds->ambiguous = ds->fn(ds->repo, current, ds->cb_data) ? 1 : 0; - return; - } - if (!ds->candidate_exists) { - /* this is the first candidate */ - oidcpy(&ds->candidate, current); - ds->candidate_exists = 1; - return; - } else if (oideq(&ds->candidate, current)) { - /* the same as what we already have seen */ - return; - } - - if (!ds->fn) { - /* cannot disambiguate between ds->candidate and current */ - ds->ambiguous = 1; - return; - } - - if (!ds->candidate_checked) { - ds->candidate_ok = ds->fn(ds->repo, &ds->candidate, ds->cb_data); - ds->disambiguate_fn_used = 1; - ds->candidate_checked = 1; - } - - if (!ds->candidate_ok) { - /* discard the candidate; we know it does not satisfy fn */ - oidcpy(&ds->candidate, current); - ds->candidate_checked = 0; - return; - } - - /* if we reach this point, we know ds->candidate satisfies fn */ - if (ds->fn(ds->repo, current, ds->cb_data)) { - /* - * if both current and candidate satisfy fn, we cannot - * disambiguate. - */ - ds->candidate_ok = 0; - ds->ambiguous = 1; - } - - /* otherwise, current can be discarded and candidate is still good */ -} - -static int match_sha(unsigned, const unsigned char *, const unsigned char *); - -static void find_short_object_filename(struct disambiguate_state *ds) -{ - struct object_directory *odb; - - for (odb = ds->repo->objects->odb; odb && !ds->ambiguous; odb = odb->next) { - int pos; - struct oid_array *loose_objects; - - loose_objects = odb_loose_cache(odb, &ds->bin_pfx); - pos = oid_array_lookup(loose_objects, &ds->bin_pfx); - if (pos < 0) - pos = -1 - pos; - while (!ds->ambiguous && pos < loose_objects->nr) { - const struct object_id *oid; - oid = loose_objects->oid + pos; - if (!match_sha(ds->len, ds->bin_pfx.hash, oid->hash)) - break; - update_candidates(ds, oid); - pos++; - } - } -} - -static int match_sha(unsigned len, const unsigned char *a, const unsigned char *b) -{ - do { - if (*a != *b) - return 0; - a++; - b++; - len -= 2; - } while (len > 1); - if (len) - if ((*a ^ *b) & 0xf0) - return 0; - return 1; -} - -static void unique_in_midx(struct multi_pack_index *m, - struct disambiguate_state *ds) -{ - uint32_t num, i, first = 0; - const struct object_id *current = NULL; - num = m->num_objects; - - if (!num) - return; - - bsearch_midx(&ds->bin_pfx, m, &first); - - /* - * At this point, "first" is the location of the lowest object - * with an object name that could match "bin_pfx". See if we have - * 0, 1 or more objects that actually match(es). - */ - for (i = first; i < num && !ds->ambiguous; i++) { - struct object_id oid; - current = nth_midxed_object_oid(&oid, m, i); - if (!match_sha(ds->len, ds->bin_pfx.hash, current->hash)) - break; - update_candidates(ds, current); - } -} - -static void unique_in_pack(struct packed_git *p, - struct disambiguate_state *ds) -{ - uint32_t num, i, first = 0; - - if (p->multi_pack_index) - return; - - if (open_pack_index(p) || !p->num_objects) - return; - - num = p->num_objects; - bsearch_pack(&ds->bin_pfx, p, &first); - - /* - * At this point, "first" is the location of the lowest object - * with an object name that could match "bin_pfx". See if we have - * 0, 1 or more objects that actually match(es). - */ - for (i = first; i < num && !ds->ambiguous; i++) { - struct object_id oid; - nth_packed_object_id(&oid, p, i); - if (!match_sha(ds->len, ds->bin_pfx.hash, oid.hash)) - break; - update_candidates(ds, &oid); - } -} - -static void find_short_packed_object(struct disambiguate_state *ds) -{ - struct multi_pack_index *m; - struct packed_git *p; - - for (m = get_multi_pack_index(ds->repo); m && !ds->ambiguous; - m = m->next) - unique_in_midx(m, ds); - for (p = get_packed_git(ds->repo); p && !ds->ambiguous; - p = p->next) - unique_in_pack(p, ds); -} - -static int finish_object_disambiguation(struct disambiguate_state *ds, - struct object_id *oid) -{ - if (ds->ambiguous) - return SHORT_NAME_AMBIGUOUS; - - if (!ds->candidate_exists) - return MISSING_OBJECT; - - if (!ds->candidate_checked) - /* - * If this is the only candidate, there is no point - * calling the disambiguation hint callback. - * - * On the other hand, if the current candidate - * replaced an earlier candidate that did _not_ pass - * the disambiguation hint callback, then we do have - * more than one objects that match the short name - * given, so we should make sure this one matches; - * otherwise, if we discovered this one and the one - * that we previously discarded in the reverse order, - * we would end up showing different results in the - * same repository! - */ - ds->candidate_ok = (!ds->disambiguate_fn_used || - ds->fn(ds->repo, &ds->candidate, ds->cb_data)); - - if (!ds->candidate_ok) - return SHORT_NAME_AMBIGUOUS; - - oidcpy(oid, &ds->candidate); - return 0; -} - -static int disambiguate_commit_only(struct repository *r, - const struct object_id *oid, - void *cb_data_unused) -{ - int kind = oid_object_info(r, oid, NULL); - return kind == OBJ_COMMIT; -} - -static int disambiguate_committish_only(struct repository *r, - const struct object_id *oid, - void *cb_data_unused) -{ - struct object *obj; - int kind; - - kind = oid_object_info(r, oid, NULL); - if (kind == OBJ_COMMIT) - return 1; - if (kind != OBJ_TAG) - return 0; - - /* We need to do this the hard way... */ - obj = deref_tag(r, parse_object(r, oid), NULL, 0); - if (obj && obj->type == OBJ_COMMIT) - return 1; - return 0; -} - -static int disambiguate_tree_only(struct repository *r, - const struct object_id *oid, - void *cb_data_unused) -{ - int kind = oid_object_info(r, oid, NULL); - return kind == OBJ_TREE; -} - -static int disambiguate_treeish_only(struct repository *r, - const struct object_id *oid, - void *cb_data_unused) -{ - struct object *obj; - int kind; - - kind = oid_object_info(r, oid, NULL); - if (kind == OBJ_TREE || kind == OBJ_COMMIT) - return 1; - if (kind != OBJ_TAG) - return 0; - - /* We need to do this the hard way... */ - obj = deref_tag(r, parse_object(r, oid), NULL, 0); - if (obj && (obj->type == OBJ_TREE || obj->type == OBJ_COMMIT)) - return 1; - return 0; -} - -static int disambiguate_blob_only(struct repository *r, - const struct object_id *oid, - void *cb_data_unused) -{ - int kind = oid_object_info(r, oid, NULL); - return kind == OBJ_BLOB; -} - -static disambiguate_hint_fn default_disambiguate_hint; - -int set_disambiguate_hint_config(const char *var, const char *value) -{ - static const struct { - const char *name; - disambiguate_hint_fn fn; - } hints[] = { - { "none", NULL }, - { "commit", disambiguate_commit_only }, - { "committish", disambiguate_committish_only }, - { "tree", disambiguate_tree_only }, - { "treeish", disambiguate_treeish_only }, - { "blob", disambiguate_blob_only } - }; - int i; - - if (!value) - return config_error_nonbool(var); - - for (i = 0; i < ARRAY_SIZE(hints); i++) { - if (!strcasecmp(value, hints[i].name)) { - default_disambiguate_hint = hints[i].fn; - return 0; - } - } - - return error("unknown hint type for '%s': %s", var, value); -} - -static int init_object_disambiguation(struct repository *r, - const char *name, int len, - struct disambiguate_state *ds) -{ - int i; - - if (len < MINIMUM_ABBREV || len > the_hash_algo->hexsz) - return -1; - - memset(ds, 0, sizeof(*ds)); - - for (i = 0; i < len ;i++) { - unsigned char c = name[i]; - unsigned char val; - if (c >= '0' && c <= '9') - val = c - '0'; - else if (c >= 'a' && c <= 'f') - val = c - 'a' + 10; - else if (c >= 'A' && c <='F') { - val = c - 'A' + 10; - c -= 'A' - 'a'; - } - else - return -1; - ds->hex_pfx[i] = c; - if (!(i & 1)) - val <<= 4; - ds->bin_pfx.hash[i >> 1] |= val; - } - - ds->len = len; - ds->hex_pfx[len] = '\0'; - ds->repo = r; - prepare_alt_odb(r); - return 0; -} - -static int show_ambiguous_object(const struct object_id *oid, void *data) -{ - const struct disambiguate_state *ds = data; - struct strbuf desc = STRBUF_INIT; - int type; - - if (ds->fn && !ds->fn(ds->repo, oid, ds->cb_data)) - return 0; - - type = oid_object_info(ds->repo, oid, NULL); - if (type == OBJ_COMMIT) { - struct commit *commit = lookup_commit(ds->repo, oid); - if (commit) { - struct pretty_print_context pp = {0}; - pp.date_mode.type = DATE_SHORT; - format_commit_message(commit, " %ad - %s", &desc, &pp); - } - } else if (type == OBJ_TAG) { - struct tag *tag = lookup_tag(ds->repo, oid); - if (!parse_tag(tag) && tag->tag) - strbuf_addf(&desc, " %s", tag->tag); - } - - advise(" %s %s%s", - repo_find_unique_abbrev(ds->repo, oid, DEFAULT_ABBREV), - type_name(type) ? type_name(type) : "unknown type", - desc.buf); - - strbuf_release(&desc); - return 0; -} - -static int collect_ambiguous(const struct object_id *oid, void *data) -{ - oid_array_append(data, oid); - return 0; -} - -static int repo_collect_ambiguous(struct repository *r, - const struct object_id *oid, - void *data) -{ - return collect_ambiguous(oid, data); -} - -static int sort_ambiguous(const void *a, const void *b, void *ctx) -{ - struct repository *sort_ambiguous_repo = ctx; - int a_type = oid_object_info(sort_ambiguous_repo, a, NULL); - int b_type = oid_object_info(sort_ambiguous_repo, b, NULL); - int a_type_sort; - int b_type_sort; - - /* - * Sorts by hash within the same object type, just as - * oid_array_for_each_unique() would do. - */ - if (a_type == b_type) - return oidcmp(a, b); - - /* - * Between object types show tags, then commits, and finally - * trees and blobs. - * - * The object_type enum is commit, tree, blob, tag, but we - * want tag, commit, tree blob. Cleverly (perhaps too - * cleverly) do that with modulus, since the enum assigns 1 to - * commit, so tag becomes 0. - */ - a_type_sort = a_type % 4; - b_type_sort = b_type % 4; - return a_type_sort > b_type_sort ? 1 : -1; -} - -static void sort_ambiguous_oid_array(struct repository *r, struct oid_array *a) -{ - QSORT_S(a->oid, a->nr, sort_ambiguous, r); -} - -static enum get_oid_result get_short_oid(struct repository *r, - const char *name, int len, - struct object_id *oid, - unsigned flags) -{ - int status; - struct disambiguate_state ds; - int quietly = !!(flags & GET_OID_QUIETLY); - - if (init_object_disambiguation(r, name, len, &ds) < 0) - return -1; - - if (HAS_MULTI_BITS(flags & GET_OID_DISAMBIGUATORS)) - BUG("multiple get_short_oid disambiguator flags"); - - if (flags & GET_OID_COMMIT) - ds.fn = disambiguate_commit_only; - else if (flags & GET_OID_COMMITTISH) - ds.fn = disambiguate_committish_only; - else if (flags & GET_OID_TREE) - ds.fn = disambiguate_tree_only; - else if (flags & GET_OID_TREEISH) - ds.fn = disambiguate_treeish_only; - else if (flags & GET_OID_BLOB) - ds.fn = disambiguate_blob_only; - else - ds.fn = default_disambiguate_hint; - - find_short_object_filename(&ds); - find_short_packed_object(&ds); - status = finish_object_disambiguation(&ds, oid); - - /* - * If we didn't find it, do the usual reprepare() slow-path, - * since the object may have recently been added to the repository - * or migrated from loose to packed. - */ - if (status == MISSING_OBJECT) { - reprepare_packed_git(r); - find_short_object_filename(&ds); - find_short_packed_object(&ds); - status = finish_object_disambiguation(&ds, oid); - } - - if (!quietly && (status == SHORT_NAME_AMBIGUOUS)) { - struct oid_array collect = OID_ARRAY_INIT; - - error(_("short SHA1 %s is ambiguous"), ds.hex_pfx); - - /* - * We may still have ambiguity if we simply saw a series of - * candidates that did not satisfy our hint function. In - * that case, we still want to show them, so disable the hint - * function entirely. - */ - if (!ds.ambiguous) - ds.fn = NULL; - - advise(_("The candidates are:")); - repo_for_each_abbrev(r, ds.hex_pfx, collect_ambiguous, &collect); - sort_ambiguous_oid_array(r, &collect); - - if (oid_array_for_each(&collect, show_ambiguous_object, &ds)) - BUG("show_ambiguous_object shouldn't return non-zero"); - oid_array_clear(&collect); - } - - return status; -} - -int repo_for_each_abbrev(struct repository *r, const char *prefix, - each_abbrev_fn fn, void *cb_data) -{ - struct oid_array collect = OID_ARRAY_INIT; - struct disambiguate_state ds; - int ret; - - if (init_object_disambiguation(r, prefix, strlen(prefix), &ds) < 0) - return -1; - - ds.always_call_fn = 1; - ds.fn = repo_collect_ambiguous; - ds.cb_data = &collect; - find_short_object_filename(&ds); - find_short_packed_object(&ds); - - ret = oid_array_for_each_unique(&collect, fn, cb_data); - oid_array_clear(&collect); - return ret; -} - -/* - * Return the slot of the most-significant bit set in "val". There are various - * ways to do this quickly with fls() or __builtin_clzl(), but speed is - * probably not a big deal here. - */ -static unsigned msb(unsigned long val) -{ - unsigned r = 0; - while (val >>= 1) - r++; - return r; -} - -struct min_abbrev_data { - unsigned int init_len; - unsigned int cur_len; - char *hex; - struct repository *repo; - const struct object_id *oid; -}; - -static inline char get_hex_char_from_oid(const struct object_id *oid, - unsigned int pos) -{ - static const char hex[] = "0123456789abcdef"; - - if ((pos & 1) == 0) - return hex[oid->hash[pos >> 1] >> 4]; - else - return hex[oid->hash[pos >> 1] & 0xf]; -} - -static int extend_abbrev_len(const struct object_id *oid, void *cb_data) -{ - struct min_abbrev_data *mad = cb_data; - - unsigned int i = mad->init_len; - while (mad->hex[i] && mad->hex[i] == get_hex_char_from_oid(oid, i)) - i++; - - if (i < GIT_MAX_RAWSZ && i >= mad->cur_len) - mad->cur_len = i + 1; - - return 0; -} - -static int repo_extend_abbrev_len(struct repository *r, - const struct object_id *oid, - void *cb_data) -{ - return extend_abbrev_len(oid, cb_data); -} - -static void find_abbrev_len_for_midx(struct multi_pack_index *m, - struct min_abbrev_data *mad) -{ - int match = 0; - uint32_t num, first = 0; - struct object_id oid; - const struct object_id *mad_oid; - - if (!m->num_objects) - return; - - num = m->num_objects; - mad_oid = mad->oid; - match = bsearch_midx(mad_oid, m, &first); - - /* - * first is now the position in the packfile where we would insert - * mad->hash if it does not exist (or the position of mad->hash if - * it does exist). Hence, we consider a maximum of two objects - * nearby for the abbreviation length. - */ - mad->init_len = 0; - if (!match) { - if (nth_midxed_object_oid(&oid, m, first)) - extend_abbrev_len(&oid, mad); - } else if (first < num - 1) { - if (nth_midxed_object_oid(&oid, m, first + 1)) - extend_abbrev_len(&oid, mad); - } - if (first > 0) { - if (nth_midxed_object_oid(&oid, m, first - 1)) - extend_abbrev_len(&oid, mad); - } - mad->init_len = mad->cur_len; -} - -static void find_abbrev_len_for_pack(struct packed_git *p, - struct min_abbrev_data *mad) -{ - int match = 0; - uint32_t num, first = 0; - struct object_id oid; - const struct object_id *mad_oid; - - if (p->multi_pack_index) - return; - - if (open_pack_index(p) || !p->num_objects) - return; - - num = p->num_objects; - mad_oid = mad->oid; - match = bsearch_pack(mad_oid, p, &first); - - /* - * first is now the position in the packfile where we would insert - * mad->hash if it does not exist (or the position of mad->hash if - * it does exist). Hence, we consider a maximum of two objects - * nearby for the abbreviation length. - */ - mad->init_len = 0; - if (!match) { - if (!nth_packed_object_id(&oid, p, first)) - extend_abbrev_len(&oid, mad); - } else if (first < num - 1) { - if (!nth_packed_object_id(&oid, p, first + 1)) - extend_abbrev_len(&oid, mad); - } - if (first > 0) { - if (!nth_packed_object_id(&oid, p, first - 1)) - extend_abbrev_len(&oid, mad); - } - mad->init_len = mad->cur_len; -} - -static void find_abbrev_len_packed(struct min_abbrev_data *mad) -{ - struct multi_pack_index *m; - struct packed_git *p; - - for (m = get_multi_pack_index(mad->repo); m; m = m->next) - find_abbrev_len_for_midx(m, mad); - for (p = get_packed_git(mad->repo); p; p = p->next) - find_abbrev_len_for_pack(p, mad); -} - -int repo_find_unique_abbrev_r(struct repository *r, char *hex, - const struct object_id *oid, int len) -{ - struct disambiguate_state ds; - struct min_abbrev_data mad; - struct object_id oid_ret; - const unsigned hexsz = r->hash_algo->hexsz; - - if (len < 0) { - unsigned long count = repo_approximate_object_count(r); - /* - * Add one because the MSB only tells us the highest bit set, - * not including the value of all the _other_ bits (so "15" - * is only one off of 2^4, but the MSB is the 3rd bit. - */ - len = msb(count) + 1; - /* - * We now know we have on the order of 2^len objects, which - * expects a collision at 2^(len/2). But we also care about hex - * chars, not bits, and there are 4 bits per hex. So all - * together we need to divide by 2 and round up. - */ - len = DIV_ROUND_UP(len, 2); - /* - * For very small repos, we stick with our regular fallback. - */ - if (len < FALLBACK_DEFAULT_ABBREV) - len = FALLBACK_DEFAULT_ABBREV; - } - - oid_to_hex_r(hex, oid); - if (len == hexsz || !len) - return hexsz; - - mad.repo = r; - mad.init_len = len; - mad.cur_len = len; - mad.hex = hex; - mad.oid = oid; - - find_abbrev_len_packed(&mad); - - if (init_object_disambiguation(r, hex, mad.cur_len, &ds) < 0) - return -1; - - ds.fn = repo_extend_abbrev_len; - ds.always_call_fn = 1; - ds.cb_data = (void *)&mad; - - find_short_object_filename(&ds); - (void)finish_object_disambiguation(&ds, &oid_ret); - - hex[mad.cur_len] = 0; - return mad.cur_len; -} - -const char *repo_find_unique_abbrev(struct repository *r, - const struct object_id *oid, - int len) -{ - static int bufno; - static char hexbuffer[4][GIT_MAX_HEXSZ + 1]; - char *hex = hexbuffer[bufno]; - bufno = (bufno + 1) % ARRAY_SIZE(hexbuffer); - repo_find_unique_abbrev_r(r, hex, oid, len); - return hex; -} - -static int ambiguous_path(const char *path, int len) -{ - int slash = 1; - int cnt; - - for (cnt = 0; cnt < len; cnt++) { - switch (*path++) { - case '\0': - break; - case '/': - if (slash) - break; - slash = 1; - continue; - case '.': - continue; - default: - slash = 0; - continue; - } - break; - } - return slash; -} - -static inline int at_mark(const char *string, int len, - const char **suffix, int nr) -{ - int i; - - for (i = 0; i < nr; i++) { - int suffix_len = strlen(suffix[i]); - if (suffix_len <= len - && !strncasecmp(string, suffix[i], suffix_len)) - return suffix_len; - } - return 0; -} - -static inline int upstream_mark(const char *string, int len) -{ - const char *suffix[] = { "@{upstream}", "@{u}" }; - return at_mark(string, len, suffix, ARRAY_SIZE(suffix)); -} - -static inline int push_mark(const char *string, int len) -{ - const char *suffix[] = { "@{push}" }; - return at_mark(string, len, suffix, ARRAY_SIZE(suffix)); -} - -static enum get_oid_result get_oid_1(struct repository *r, const char *name, int len, struct object_id *oid, unsigned lookup_flags); -static int interpret_nth_prior_checkout(struct repository *r, const char *name, int namelen, struct strbuf *buf); - -static int get_oid_basic(struct repository *r, const char *str, int len, - struct object_id *oid, unsigned int flags) -{ - static const char *warn_msg = "refname '%.*s' is ambiguous."; - static const char *object_name_msg = N_( - "Git normally never creates a ref that ends with 40 hex characters\n" - "because it will be ignored when you just specify 40-hex. These refs\n" - "may be created by mistake. For example,\n" - "\n" - " git switch -c $br $(git rev-parse ...)\n" - "\n" - "where \"$br\" is somehow empty and a 40-hex ref is created. Please\n" - "examine these refs and maybe delete them. Turn this message off by\n" - "running \"git config advice.objectNameWarning false\""); - struct object_id tmp_oid; - char *real_ref = NULL; - int refs_found = 0; - int at, reflog_len, nth_prior = 0; - - if (len == r->hash_algo->hexsz && !get_oid_hex(str, oid)) { - if (warn_ambiguous_refs && warn_on_object_refname_ambiguity) { - refs_found = repo_dwim_ref(r, str, len, &tmp_oid, &real_ref, 0); - if (refs_found > 0) { - warning(warn_msg, len, str); - if (advice_object_name_warning) - fprintf(stderr, "%s\n", _(object_name_msg)); - } - free(real_ref); - } - return 0; - } - - /* basic@{time or number or -number} format to query ref-log */ - reflog_len = at = 0; - if (len && str[len-1] == '}') { - for (at = len-4; at >= 0; at--) { - if (str[at] == '@' && str[at+1] == '{') { - if (str[at+2] == '-') { - if (at != 0) - /* @{-N} not at start */ - return -1; - nth_prior = 1; - continue; - } - if (!upstream_mark(str + at, len - at) && - !push_mark(str + at, len - at)) { - reflog_len = (len-1) - (at+2); - len = at; - } - break; - } - } - } - - /* Accept only unambiguous ref paths. */ - if (len && ambiguous_path(str, len)) - return -1; - - if (nth_prior) { - struct strbuf buf = STRBUF_INIT; - int detached; - - if (interpret_nth_prior_checkout(r, str, len, &buf) > 0) { - detached = (buf.len == r->hash_algo->hexsz && !get_oid_hex(buf.buf, oid)); - strbuf_release(&buf); - if (detached) - return 0; - } - } - - if (!len && reflog_len) - /* allow "@{...}" to mean the current branch reflog */ - refs_found = repo_dwim_ref(r, "HEAD", 4, oid, &real_ref, 0); - else if (reflog_len) - refs_found = repo_dwim_log(r, str, len, oid, &real_ref); - else - refs_found = repo_dwim_ref(r, str, len, oid, &real_ref, 0); - - if (!refs_found) - return -1; - - if (warn_ambiguous_refs && !(flags & GET_OID_QUIETLY) && - (refs_found > 1 || - !get_short_oid(r, str, len, &tmp_oid, GET_OID_QUIETLY))) - warning(warn_msg, len, str); - - if (reflog_len) { - int nth, i; - timestamp_t at_time; - timestamp_t co_time; - int co_tz, co_cnt; - - /* Is it asking for N-th entry, or approxidate? */ - for (i = nth = 0; 0 <= nth && i < reflog_len; i++) { - char ch = str[at+2+i]; - if ('0' <= ch && ch <= '9') - nth = nth * 10 + ch - '0'; - else - nth = -1; - } - if (100000000 <= nth) { - at_time = nth; - nth = -1; - } else if (0 <= nth) - at_time = 0; - else { - int errors = 0; - char *tmp = xstrndup(str + at + 2, reflog_len); - at_time = approxidate_careful(tmp, &errors); - free(tmp); - if (errors) { - free(real_ref); - return -1; - } - } - if (read_ref_at(get_main_ref_store(r), - real_ref, flags, at_time, nth, oid, NULL, - &co_time, &co_tz, &co_cnt)) { - if (!len) { - if (!skip_prefix(real_ref, "refs/heads/", &str)) - str = "HEAD"; - len = strlen(str); - } - if (at_time) { - if (!(flags & GET_OID_QUIETLY)) { - warning(_("log for '%.*s' only goes back to %s"), - len, str, - show_date(co_time, co_tz, DATE_MODE(RFC2822))); - } - } else { - if (flags & GET_OID_QUIETLY) { - exit(128); - } - die(_("log for '%.*s' only has %d entries"), - len, str, co_cnt); - } - } - } - - free(real_ref); - return 0; -} - -static enum get_oid_result get_parent(struct repository *r, - const char *name, int len, - struct object_id *result, int idx) -{ - struct object_id oid; - enum get_oid_result ret = get_oid_1(r, name, len, &oid, - GET_OID_COMMITTISH); - struct commit *commit; - struct commit_list *p; - - if (ret) - return ret; - commit = lookup_commit_reference(r, &oid); - if (parse_commit(commit)) - return MISSING_OBJECT; - if (!idx) { - oidcpy(result, &commit->object.oid); - return FOUND; - } - p = commit->parents; - while (p) { - if (!--idx) { - oidcpy(result, &p->item->object.oid); - return FOUND; - } - p = p->next; - } - return MISSING_OBJECT; -} - -static enum get_oid_result get_nth_ancestor(struct repository *r, - const char *name, int len, - struct object_id *result, - int generation) -{ - struct object_id oid; - struct commit *commit; - int ret; - - ret = get_oid_1(r, name, len, &oid, GET_OID_COMMITTISH); - if (ret) - return ret; - commit = lookup_commit_reference(r, &oid); - if (!commit) - return MISSING_OBJECT; - - while (generation--) { - if (parse_commit(commit) || !commit->parents) - return MISSING_OBJECT; - commit = commit->parents->item; - } - oidcpy(result, &commit->object.oid); - return FOUND; -} - -struct object *repo_peel_to_type(struct repository *r, const char *name, int namelen, - struct object *o, enum object_type expected_type) -{ - if (name && !namelen) - namelen = strlen(name); - while (1) { - if (!o || (!o->parsed && !parse_object(r, &o->oid))) - return NULL; - if (expected_type == OBJ_ANY || o->type == expected_type) - return o; - if (o->type == OBJ_TAG) - o = ((struct tag*) o)->tagged; - else if (o->type == OBJ_COMMIT) - o = &(repo_get_commit_tree(r, ((struct commit *)o))->object); - else { - if (name) - error("%.*s: expected %s type, but the object " - "dereferences to %s type", - namelen, name, type_name(expected_type), - type_name(o->type)); - return NULL; - } - } -} - -static int peel_onion(struct repository *r, const char *name, int len, - struct object_id *oid, unsigned lookup_flags) -{ - struct object_id outer; - const char *sp; - unsigned int expected_type = 0; - struct object *o; - - /* - * "ref^{type}" dereferences ref repeatedly until you cannot - * dereference anymore, or you get an object of given type, - * whichever comes first. "ref^{}" means just dereference - * tags until you get a non-tag. "ref^0" is a shorthand for - * "ref^{commit}". "commit^{tree}" could be used to find the - * top-level tree of the given commit. - */ - if (len < 4 || name[len-1] != '}') - return -1; - - for (sp = name + len - 1; name <= sp; sp--) { - int ch = *sp; - if (ch == '{' && name < sp && sp[-1] == '^') - break; - } - if (sp <= name) - return -1; - - sp++; /* beginning of type name, or closing brace for empty */ - if (starts_with(sp, "commit}")) - expected_type = OBJ_COMMIT; - else if (starts_with(sp, "tag}")) - expected_type = OBJ_TAG; - else if (starts_with(sp, "tree}")) - expected_type = OBJ_TREE; - else if (starts_with(sp, "blob}")) - expected_type = OBJ_BLOB; - else if (starts_with(sp, "object}")) - expected_type = OBJ_ANY; - else if (sp[0] == '}') - expected_type = OBJ_NONE; - else if (sp[0] == '/') - expected_type = OBJ_COMMIT; - else - return -1; - - lookup_flags &= ~GET_OID_DISAMBIGUATORS; - if (expected_type == OBJ_COMMIT) - lookup_flags |= GET_OID_COMMITTISH; - else if (expected_type == OBJ_TREE) - lookup_flags |= GET_OID_TREEISH; - - if (get_oid_1(r, name, sp - name - 2, &outer, lookup_flags)) - return -1; - - o = parse_object(r, &outer); - if (!o) - return -1; - if (!expected_type) { - o = deref_tag(r, o, name, sp - name - 2); - if (!o || (!o->parsed && !parse_object(r, &o->oid))) - return -1; - oidcpy(oid, &o->oid); - return 0; - } - - /* - * At this point, the syntax look correct, so - * if we do not get the needed object, we should - * barf. - */ - o = repo_peel_to_type(r, name, len, o, expected_type); - if (!o) - return -1; - - oidcpy(oid, &o->oid); - if (sp[0] == '/') { - /* "$commit^{/foo}" */ - char *prefix; - int ret; - struct commit_list *list = NULL; - - /* - * $commit^{/}. Some regex implementation may reject. - * We don't need regex anyway. '' pattern always matches. - */ - if (sp[1] == '}') - return 0; - - prefix = xstrndup(sp + 1, name + len - 1 - (sp + 1)); - commit_list_insert((struct commit *)o, &list); - ret = get_oid_oneline(r, prefix, oid, list); - free(prefix); - return ret; - } - return 0; -} - -static int get_describe_name(struct repository *r, - const char *name, int len, - struct object_id *oid) -{ - const char *cp; - unsigned flags = GET_OID_QUIETLY | GET_OID_COMMIT; - - for (cp = name + len - 1; name + 2 <= cp; cp--) { - char ch = *cp; - if (!isxdigit(ch)) { - /* We must be looking at g in "SOMETHING-g" - * for it to be describe output. - */ - if (ch == 'g' && cp[-1] == '-') { - cp++; - len -= cp - name; - return get_short_oid(r, - cp, len, oid, flags); - } - } - } - return -1; -} - -static enum get_oid_result get_oid_1(struct repository *r, - const char *name, int len, - struct object_id *oid, - unsigned lookup_flags) -{ - int ret, has_suffix; - const char *cp; - - /* - * "name~3" is "name^^^", "name~" is "name~1", and "name^" is "name^1". - */ - has_suffix = 0; - for (cp = name + len - 1; name <= cp; cp--) { - int ch = *cp; - if ('0' <= ch && ch <= '9') - continue; - if (ch == '~' || ch == '^') - has_suffix = ch; - break; - } - - if (has_suffix) { - unsigned int num = 0; - int len1 = cp - name; - cp++; - while (cp < name + len) { - unsigned int digit = *cp++ - '0'; - if (unsigned_mult_overflows(num, 10)) - return MISSING_OBJECT; - num *= 10; - if (unsigned_add_overflows(num, digit)) - return MISSING_OBJECT; - num += digit; - } - if (!num && len1 == len - 1) - num = 1; - else if (num > INT_MAX) - return MISSING_OBJECT; - if (has_suffix == '^') - return get_parent(r, name, len1, oid, num); - /* else if (has_suffix == '~') -- goes without saying */ - return get_nth_ancestor(r, name, len1, oid, num); - } - - ret = peel_onion(r, name, len, oid, lookup_flags); - if (!ret) - return FOUND; - - ret = get_oid_basic(r, name, len, oid, lookup_flags); - if (!ret) - return FOUND; - - /* It could be describe output that is "SOMETHING-gXXXX" */ - ret = get_describe_name(r, name, len, oid); - if (!ret) - return FOUND; - - return get_short_oid(r, name, len, oid, lookup_flags); -} - -/* - * This interprets names like ':/Initial revision of "git"' by searching - * through history and returning the first commit whose message starts - * the given regular expression. - * - * For negative-matching, prefix the pattern-part with '!-', like: ':/!-WIP'. - * - * For a literal '!' character at the beginning of a pattern, you have to repeat - * that, like: ':/!!foo' - * - * For future extension, all other sequences beginning with ':/!' are reserved. - */ - -/* Remember to update object flag allocation in object.h */ -#define ONELINE_SEEN (1u<<20) - -struct handle_one_ref_cb { - struct repository *repo; - struct commit_list **list; -}; - -static int handle_one_ref(const char *path, const struct object_id *oid, - int flag, void *cb_data) -{ - struct handle_one_ref_cb *cb = cb_data; - struct commit_list **list = cb->list; - struct object *object = parse_object(cb->repo, oid); - if (!object) - return 0; - if (object->type == OBJ_TAG) { - object = deref_tag(cb->repo, object, path, - strlen(path)); - if (!object) - return 0; - } - if (object->type != OBJ_COMMIT) - return 0; - commit_list_insert((struct commit *)object, list); - return 0; -} - -static int get_oid_oneline(struct repository *r, - const char *prefix, struct object_id *oid, - struct commit_list *list) -{ - struct commit_list *backup = NULL, *l; - int found = 0; - int negative = 0; - regex_t regex; - - if (prefix[0] == '!') { - prefix++; - - if (prefix[0] == '-') { - prefix++; - negative = 1; - } else if (prefix[0] != '!') { - return -1; - } - } - - if (regcomp(®ex, prefix, REG_EXTENDED)) - return -1; - - for (l = list; l; l = l->next) { - l->item->object.flags |= ONELINE_SEEN; - commit_list_insert(l->item, &backup); - } - while (list) { - const char *p, *buf; - struct commit *commit; - int matches; - - commit = pop_most_recent_commit(&list, ONELINE_SEEN); - if (!parse_object(r, &commit->object.oid)) - continue; - buf = get_commit_buffer(commit, NULL); - p = strstr(buf, "\n\n"); - matches = negative ^ (p && !regexec(®ex, p + 2, 0, NULL, 0)); - unuse_commit_buffer(commit, buf); - - if (matches) { - oidcpy(oid, &commit->object.oid); - found = 1; - break; - } - } - regfree(®ex); - free_commit_list(list); - for (l = backup; l; l = l->next) - clear_commit_marks(l->item, ONELINE_SEEN); - free_commit_list(backup); - return found ? 0 : -1; -} - -struct grab_nth_branch_switch_cbdata { - int remaining; - struct strbuf *sb; -}; - -static int grab_nth_branch_switch(struct object_id *ooid, struct object_id *noid, - const char *email, timestamp_t timestamp, int tz, - const char *message, void *cb_data) -{ - struct grab_nth_branch_switch_cbdata *cb = cb_data; - const char *match = NULL, *target = NULL; - size_t len; - - if (skip_prefix(message, "checkout: moving from ", &match)) - target = strstr(match, " to "); - - if (!match || !target) - return 0; - if (--(cb->remaining) == 0) { - len = target - match; - strbuf_reset(cb->sb); - strbuf_add(cb->sb, match, len); - return 1; /* we are done */ - } - return 0; -} - -/* - * Parse @{-N} syntax, return the number of characters parsed - * if successful; otherwise signal an error with negative value. - */ -static int interpret_nth_prior_checkout(struct repository *r, - const char *name, int namelen, - struct strbuf *buf) -{ - long nth; - int retval; - struct grab_nth_branch_switch_cbdata cb; - const char *brace; - char *num_end; - - if (namelen < 4) - return -1; - if (name[0] != '@' || name[1] != '{' || name[2] != '-') - return -1; - brace = memchr(name, '}', namelen); - if (!brace) - return -1; - nth = strtol(name + 3, &num_end, 10); - if (num_end != brace) - return -1; - if (nth <= 0) - return -1; - cb.remaining = nth; - cb.sb = buf; - - retval = refs_for_each_reflog_ent_reverse(get_main_ref_store(r), - "HEAD", grab_nth_branch_switch, &cb); - if (0 < retval) { - retval = brace - name + 1; - } else - retval = 0; - - return retval; -} - -int repo_get_oid_mb(struct repository *r, - const char *name, - struct object_id *oid) -{ - struct commit *one, *two; - struct commit_list *mbs; - struct object_id oid_tmp; - const char *dots; - int st; - - dots = strstr(name, "..."); - if (!dots) - return repo_get_oid(r, name, oid); - if (dots == name) - st = repo_get_oid(r, "HEAD", &oid_tmp); - else { - struct strbuf sb; - strbuf_init(&sb, dots - name); - strbuf_add(&sb, name, dots - name); - st = repo_get_oid_committish(r, sb.buf, &oid_tmp); - strbuf_release(&sb); - } - if (st) - return st; - one = lookup_commit_reference_gently(r, &oid_tmp, 0); - if (!one) - return -1; - - if (repo_get_oid_committish(r, dots[3] ? (dots + 3) : "HEAD", &oid_tmp)) - return -1; - two = lookup_commit_reference_gently(r, &oid_tmp, 0); - if (!two) - return -1; - mbs = repo_get_merge_bases(r, one, two); - if (!mbs || mbs->next) - st = -1; - else { - st = 0; - oidcpy(oid, &mbs->item->object.oid); - } - free_commit_list(mbs); - return st; -} - -/* parse @something syntax, when 'something' is not {.*} */ -static int interpret_empty_at(const char *name, int namelen, int len, struct strbuf *buf) -{ - const char *next; - - if (len || name[1] == '{') - return -1; - - /* make sure it's a single @, or @@{.*}, not @foo */ - next = memchr(name + len + 1, '@', namelen - len - 1); - if (next && next[1] != '{') - return -1; - if (!next) - next = name + namelen; - if (next != name + 1) - return -1; - - strbuf_reset(buf); - strbuf_add(buf, "HEAD", 4); - return 1; -} - -static int reinterpret(struct repository *r, - const char *name, int namelen, int len, - struct strbuf *buf, unsigned allowed) -{ - /* we have extra data, which might need further processing */ - struct strbuf tmp = STRBUF_INIT; - int used = buf->len; - int ret; - struct interpret_branch_name_options options = { - .allowed = allowed - }; - - strbuf_add(buf, name + len, namelen - len); - ret = repo_interpret_branch_name(r, buf->buf, buf->len, &tmp, &options); - /* that data was not interpreted, remove our cruft */ - if (ret < 0) { - strbuf_setlen(buf, used); - return len; - } - strbuf_reset(buf); - strbuf_addbuf(buf, &tmp); - strbuf_release(&tmp); - /* tweak for size of {-N} versus expanded ref name */ - return ret - used + len; -} - -static void set_shortened_ref(struct repository *r, struct strbuf *buf, const char *ref) -{ - char *s = refs_shorten_unambiguous_ref(get_main_ref_store(r), ref, 0); - strbuf_reset(buf); - strbuf_addstr(buf, s); - free(s); -} - -static int branch_interpret_allowed(const char *refname, unsigned allowed) -{ - if (!allowed) - return 1; - - if ((allowed & INTERPRET_BRANCH_LOCAL) && - starts_with(refname, "refs/heads/")) - return 1; - if ((allowed & INTERPRET_BRANCH_REMOTE) && - starts_with(refname, "refs/remotes/")) - return 1; - - return 0; -} - -static int interpret_branch_mark(struct repository *r, - const char *name, int namelen, - int at, struct strbuf *buf, - int (*get_mark)(const char *, int), - const char *(*get_data)(struct branch *, - struct strbuf *), - const struct interpret_branch_name_options *options) -{ - int len; - struct branch *branch; - struct strbuf err = STRBUF_INIT; - const char *value; - - len = get_mark(name + at, namelen - at); - if (!len) - return -1; - - if (memchr(name, ':', at)) - return -1; - - if (at) { - char *name_str = xmemdupz(name, at); - branch = branch_get(name_str); - free(name_str); - } else - branch = branch_get(NULL); - - value = get_data(branch, &err); - if (!value) { - if (options->nonfatal_dangling_mark) { - strbuf_release(&err); - return -1; - } else { - die("%s", err.buf); - } - } - - if (!branch_interpret_allowed(value, options->allowed)) - return -1; - - set_shortened_ref(r, buf, value); - return len + at; -} - -int repo_interpret_branch_name(struct repository *r, - const char *name, int namelen, - struct strbuf *buf, - const struct interpret_branch_name_options *options) -{ - char *at; - const char *start; - int len; - - if (!namelen) - namelen = strlen(name); - - if (!options->allowed || (options->allowed & INTERPRET_BRANCH_LOCAL)) { - len = interpret_nth_prior_checkout(r, name, namelen, buf); - if (!len) { - return len; /* syntax Ok, not enough switches */ - } else if (len > 0) { - if (len == namelen) - return len; /* consumed all */ - else - return reinterpret(r, name, namelen, len, buf, - options->allowed); - } - } - - for (start = name; - (at = memchr(start, '@', namelen - (start - name))); - start = at + 1) { - - if (!options->allowed || (options->allowed & INTERPRET_BRANCH_HEAD)) { - len = interpret_empty_at(name, namelen, at - name, buf); - if (len > 0) - return reinterpret(r, name, namelen, len, buf, - options->allowed); - } - - len = interpret_branch_mark(r, name, namelen, at - name, buf, - upstream_mark, branch_get_upstream, - options); - if (len > 0) - return len; - - len = interpret_branch_mark(r, name, namelen, at - name, buf, - push_mark, branch_get_push, - options); - if (len > 0) - return len; - } - - return -1; -} - -void strbuf_branchname(struct strbuf *sb, const char *name, unsigned allowed) -{ - int len = strlen(name); - struct interpret_branch_name_options options = { - .allowed = allowed - }; - int used = interpret_branch_name(name, len, sb, &options); - - if (used < 0) - used = 0; - strbuf_add(sb, name + used, len - used); -} - -int strbuf_check_branch_ref(struct strbuf *sb, const char *name) -{ - if (startup_info->have_repository) - strbuf_branchname(sb, name, INTERPRET_BRANCH_LOCAL); - else - strbuf_addstr(sb, name); - - /* - * This splice must be done even if we end up rejecting the - * name; builtin/branch.c::copy_or_rename_branch() still wants - * to see what the name expanded to so that "branch -m" can be - * used as a tool to correct earlier mistakes. - */ - strbuf_splice(sb, 0, 0, "refs/heads/", 11); - - if (*name == '-' || - !strcmp(sb->buf, "refs/heads/HEAD")) - return -1; - - return check_refname_format(sb->buf, 0); -} - -/* - * This is like "get_oid_basic()", except it allows "object ID expressions", - * notably "xyz^" for "parent of xyz" - */ -int repo_get_oid(struct repository *r, const char *name, struct object_id *oid) -{ - struct object_context unused; - return get_oid_with_context(r, name, 0, oid, &unused); -} - -/* - * This returns a non-zero value if the string (built using printf - * format and the given arguments) is not a valid object. - */ -int get_oidf(struct object_id *oid, const char *fmt, ...) -{ - va_list ap; - int ret; - struct strbuf sb = STRBUF_INIT; - - va_start(ap, fmt); - strbuf_vaddf(&sb, fmt, ap); - va_end(ap); - - ret = get_oid(sb.buf, oid); - strbuf_release(&sb); - - return ret; -} - -/* - * Many callers know that the user meant to name a commit-ish by - * syntactical positions where the object name appears. Calling this - * function allows the machinery to disambiguate shorter-than-unique - * abbreviated object names between commit-ish and others. - * - * Note that this does NOT error out when the named object is not a - * commit-ish. It is merely to give a hint to the disambiguation - * machinery. - */ -int repo_get_oid_committish(struct repository *r, - const char *name, - struct object_id *oid) -{ - struct object_context unused; - return get_oid_with_context(r, name, GET_OID_COMMITTISH, - oid, &unused); -} - -int repo_get_oid_treeish(struct repository *r, - const char *name, - struct object_id *oid) -{ - struct object_context unused; - return get_oid_with_context(r, name, GET_OID_TREEISH, - oid, &unused); -} - -int repo_get_oid_commit(struct repository *r, - const char *name, - struct object_id *oid) -{ - struct object_context unused; - return get_oid_with_context(r, name, GET_OID_COMMIT, - oid, &unused); -} - -int repo_get_oid_tree(struct repository *r, - const char *name, - struct object_id *oid) -{ - struct object_context unused; - return get_oid_with_context(r, name, GET_OID_TREE, - oid, &unused); -} - -int repo_get_oid_blob(struct repository *r, - const char *name, - struct object_id *oid) -{ - struct object_context unused; - return get_oid_with_context(r, name, GET_OID_BLOB, - oid, &unused); -} - -/* Must be called only when object_name:filename doesn't exist. */ -static void diagnose_invalid_oid_path(struct repository *r, - const char *prefix, - const char *filename, - const struct object_id *tree_oid, - const char *object_name, - int object_name_len) -{ - struct object_id oid; - unsigned short mode; - - if (!prefix) - prefix = ""; - - if (file_exists(filename)) - die(_("path '%s' exists on disk, but not in '%.*s'"), - filename, object_name_len, object_name); - if (is_missing_file_error(errno)) { - char *fullname = xstrfmt("%s%s", prefix, filename); - - if (!get_tree_entry(r, tree_oid, fullname, &oid, &mode)) { - die(_("path '%s' exists, but not '%s'\n" - "hint: Did you mean '%.*s:%s' aka '%.*s:./%s'?"), - fullname, - filename, - object_name_len, object_name, - fullname, - object_name_len, object_name, - filename); - } - die(_("path '%s' does not exist in '%.*s'"), - filename, object_name_len, object_name); - } -} - -/* Must be called only when :stage:filename doesn't exist. */ -static void diagnose_invalid_index_path(struct repository *r, - int stage, - const char *prefix, - const char *filename) -{ - struct index_state *istate = r->index; - const struct cache_entry *ce; - int pos; - unsigned namelen = strlen(filename); - struct strbuf fullname = STRBUF_INIT; - - if (!prefix) - prefix = ""; - - /* Wrong stage number? */ - pos = index_name_pos(istate, filename, namelen); - if (pos < 0) - pos = -pos - 1; - if (pos < istate->cache_nr) { - ce = istate->cache[pos]; - if (ce_namelen(ce) == namelen && - !memcmp(ce->name, filename, namelen)) - die(_("path '%s' is in the index, but not at stage %d\n" - "hint: Did you mean ':%d:%s'?"), - filename, stage, - ce_stage(ce), filename); - } - - /* Confusion between relative and absolute filenames? */ - strbuf_addstr(&fullname, prefix); - strbuf_addstr(&fullname, filename); - pos = index_name_pos(istate, fullname.buf, fullname.len); - if (pos < 0) - pos = -pos - 1; - if (pos < istate->cache_nr) { - ce = istate->cache[pos]; - if (ce_namelen(ce) == fullname.len && - !memcmp(ce->name, fullname.buf, fullname.len)) - die(_("path '%s' is in the index, but not '%s'\n" - "hint: Did you mean ':%d:%s' aka ':%d:./%s'?"), - fullname.buf, filename, - ce_stage(ce), fullname.buf, - ce_stage(ce), filename); - } - - if (repo_file_exists(r, filename)) - die(_("path '%s' exists on disk, but not in the index"), filename); - if (is_missing_file_error(errno)) - die(_("path '%s' does not exist (neither on disk nor in the index)"), - filename); - - strbuf_release(&fullname); -} - - -static char *resolve_relative_path(struct repository *r, const char *rel) -{ - if (!starts_with(rel, "./") && !starts_with(rel, "../")) - return NULL; - - if (r != the_repository || !is_inside_work_tree()) - die(_("relative path syntax can't be used outside working tree")); - - /* die() inside prefix_path() if resolved path is outside worktree */ - return prefix_path(startup_info->prefix, - startup_info->prefix ? strlen(startup_info->prefix) : 0, - rel); -} - -static enum get_oid_result get_oid_with_context_1(struct repository *repo, - const char *name, - unsigned flags, - const char *prefix, - struct object_id *oid, - struct object_context *oc) -{ - int ret, bracket_depth; - int namelen = strlen(name); - const char *cp; - int only_to_die = flags & GET_OID_ONLY_TO_DIE; - - if (only_to_die) - flags |= GET_OID_QUIETLY; - - memset(oc, 0, sizeof(*oc)); - oc->mode = S_IFINVALID; - strbuf_init(&oc->symlink_path, 0); - ret = get_oid_1(repo, name, namelen, oid, flags); - if (!ret) - return ret; - /* - * sha1:path --> object name of path in ent sha1 - * :path -> object name of absolute path in index - * :./path -> object name of path relative to cwd in index - * :[0-3]:path -> object name of path in index at stage - * :/foo -> recent commit matching foo - */ - if (name[0] == ':') { - int stage = 0; - const struct cache_entry *ce; - char *new_path = NULL; - int pos; - if (!only_to_die && namelen > 2 && name[1] == '/') { - struct handle_one_ref_cb cb; - struct commit_list *list = NULL; - - cb.repo = repo; - cb.list = &list; - refs_for_each_ref(get_main_ref_store(repo), handle_one_ref, &cb); - refs_head_ref(get_main_ref_store(repo), handle_one_ref, &cb); - commit_list_sort_by_date(&list); - return get_oid_oneline(repo, name + 2, oid, list); - } - if (namelen < 3 || - name[2] != ':' || - name[1] < '0' || '3' < name[1]) - cp = name + 1; - else { - stage = name[1] - '0'; - cp = name + 3; - } - new_path = resolve_relative_path(repo, cp); - if (!new_path) { - namelen = namelen - (cp - name); - } else { - cp = new_path; - namelen = strlen(cp); - } - - if (flags & GET_OID_RECORD_PATH) - oc->path = xstrdup(cp); - - if (!repo->index || !repo->index->cache) - repo_read_index(repo); - pos = index_name_pos(repo->index, cp, namelen); - if (pos < 0) - pos = -pos - 1; - while (pos < repo->index->cache_nr) { - ce = repo->index->cache[pos]; - if (ce_namelen(ce) != namelen || - memcmp(ce->name, cp, namelen)) - break; - if (ce_stage(ce) == stage) { - oidcpy(oid, &ce->oid); - oc->mode = ce->ce_mode; - free(new_path); - return 0; - } - pos++; - } - if (only_to_die && name[1] && name[1] != '/') - diagnose_invalid_index_path(repo, stage, prefix, cp); - free(new_path); - return -1; - } - for (cp = name, bracket_depth = 0; *cp; cp++) { - if (*cp == '{') - bracket_depth++; - else if (bracket_depth && *cp == '}') - bracket_depth--; - else if (!bracket_depth && *cp == ':') - break; - } - if (*cp == ':') { - struct object_id tree_oid; - int len = cp - name; - unsigned sub_flags = flags; - - sub_flags &= ~GET_OID_DISAMBIGUATORS; - sub_flags |= GET_OID_TREEISH; - - if (!get_oid_1(repo, name, len, &tree_oid, sub_flags)) { - const char *filename = cp+1; - char *new_filename = NULL; - - new_filename = resolve_relative_path(repo, filename); - if (new_filename) - filename = new_filename; - if (flags & GET_OID_FOLLOW_SYMLINKS) { - ret = get_tree_entry_follow_symlinks(repo, &tree_oid, - filename, oid, &oc->symlink_path, - &oc->mode); - } else { - ret = get_tree_entry(repo, &tree_oid, filename, oid, - &oc->mode); - if (ret && only_to_die) { - diagnose_invalid_oid_path(repo, prefix, - filename, - &tree_oid, - name, len); - } - } - if (flags & GET_OID_RECORD_PATH) - oc->path = xstrdup(filename); - - free(new_filename); - return ret; - } else { - if (only_to_die) - die(_("invalid object name '%.*s'."), len, name); - } - } - return ret; -} - -/* - * Call this function when you know "name" given by the end user must - * name an object but it doesn't; the function _may_ die with a better - * diagnostic message than "no such object 'name'", e.g. "Path 'doc' does not - * exist in 'HEAD'" when given "HEAD:doc", or it may return in which case - * you have a chance to diagnose the error further. - */ -void maybe_die_on_misspelt_object_name(struct repository *r, - const char *name, - const char *prefix) -{ - struct object_context oc; - struct object_id oid; - get_oid_with_context_1(r, name, GET_OID_ONLY_TO_DIE, - prefix, &oid, &oc); -} - -enum get_oid_result get_oid_with_context(struct repository *repo, - const char *str, - unsigned flags, - struct object_id *oid, - struct object_context *oc) -{ - if (flags & GET_OID_FOLLOW_SYMLINKS && flags & GET_OID_ONLY_TO_DIE) - BUG("incompatible flags for get_sha1_with_context"); - return get_oid_with_context_1(repo, str, flags, NULL, oid, oc); -} diff --git a/t/t1512-rev-parse-disambiguation.sh b/t/t1512-rev-parse-disambiguation.sh index 18fa6cf40d..cc889d7a84 100755 --- a/t/t1512-rev-parse-disambiguation.sh +++ b/t/t1512-rev-parse-disambiguation.sh @@ -48,7 +48,7 @@ test_expect_success 'blob and tree' ' test_expect_success 'warn ambiguity when no candidate matches type hint' ' test_must_fail git rev-parse --verify 000000000^{commit} 2>actual && - test_i18ngrep "short SHA1 000000000 is ambiguous" actual + test_i18ngrep "short object ID 000000000 is ambiguous" actual ' test_expect_success 'disambiguate tree-ish' ' -- cgit v1.3-5-g9baa From e5afd4449d7f1adfd02eca573c23e7ae9c96b28d Mon Sep 17 00:00:00 2001 From: Martin Ågren Date: Thu, 31 Dec 2020 12:56:21 +0100 Subject: object-file.c: rename from sha1-file.c MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Drop the last remnant of "sha1" in this file and rename it to reflect that we're not just able to handle SHA-1 these days. Signed-off-by: Martin Ågren Reviewed-by: Derrick Stolee Signed-off-by: Junio C Hamano --- Makefile | 2 +- builtin/index-pack.c | 2 +- object-file.c | 2554 ++++++++++++++++++++++++++++++++++++++++++++++++++ sha1-file.c | 2554 -------------------------------------------------- t/oid-info/README | 2 +- 5 files changed, 2557 insertions(+), 2557 deletions(-) create mode 100644 object-file.c delete mode 100644 sha1-file.c diff --git a/Makefile b/Makefile index 8bb1163f70..224a1c6940 100644 --- a/Makefile +++ b/Makefile @@ -937,6 +937,7 @@ LIB_OBJS += notes-cache.o LIB_OBJS += notes-merge.o LIB_OBJS += notes-utils.o LIB_OBJS += notes.o +LIB_OBJS += object-file.o LIB_OBJS += object-name.o LIB_OBJS += object.o LIB_OBJS += oid-array.o @@ -994,7 +995,6 @@ LIB_OBJS += sequencer.o LIB_OBJS += serve.o LIB_OBJS += server-info.o LIB_OBJS += setup.o -LIB_OBJS += sha1-file.o LIB_OBJS += sha1-lookup.o LIB_OBJS += shallow.o LIB_OBJS += sideband.o diff --git a/builtin/index-pack.c b/builtin/index-pack.c index 4b8d86e0ad..557bd2f348 100644 --- a/builtin/index-pack.c +++ b/builtin/index-pack.c @@ -1641,7 +1641,7 @@ static void read_idx_option(struct pack_idx_option *opts, const char *pack_name) /* * Get rid of the idx file as we do not need it anymore. * NEEDSWORK: extract this bit from free_pack_by_name() in - * sha1-file.c, perhaps? It shouldn't matter very much as we + * object-file.c, perhaps? It shouldn't matter very much as we * know we haven't installed this pack (hence we never have * read anything from it). */ diff --git a/object-file.c b/object-file.c new file mode 100644 index 0000000000..3508598d97 --- /dev/null +++ b/object-file.c @@ -0,0 +1,2554 @@ +/* + * GIT - The information manager from hell + * + * Copyright (C) Linus Torvalds, 2005 + * + * This handles basic git object files - packing, unpacking, + * creation etc. + */ +#include "cache.h" +#include "config.h" +#include "string-list.h" +#include "lockfile.h" +#include "delta.h" +#include "pack.h" +#include "blob.h" +#include "commit.h" +#include "run-command.h" +#include "tag.h" +#include "tree.h" +#include "tree-walk.h" +#include "refs.h" +#include "pack-revindex.h" +#include "sha1-lookup.h" +#include "bulk-checkin.h" +#include "repository.h" +#include "replace-object.h" +#include "streaming.h" +#include "dir.h" +#include "list.h" +#include "mergesort.h" +#include "quote.h" +#include "packfile.h" +#include "object-store.h" +#include "promisor-remote.h" + +/* The maximum size for an object header. */ +#define MAX_HEADER_LEN 32 + + +#define EMPTY_TREE_SHA1_BIN_LITERAL \ + "\x4b\x82\x5d\xc6\x42\xcb\x6e\xb9\xa0\x60" \ + "\xe5\x4b\xf8\xd6\x92\x88\xfb\xee\x49\x04" +#define EMPTY_TREE_SHA256_BIN_LITERAL \ + "\x6e\xf1\x9b\x41\x22\x5c\x53\x69\xf1\xc1" \ + "\x04\xd4\x5d\x8d\x85\xef\xa9\xb0\x57\xb5" \ + "\x3b\x14\xb4\xb9\xb9\x39\xdd\x74\xde\xcc" \ + "\x53\x21" + +#define EMPTY_BLOB_SHA1_BIN_LITERAL \ + "\xe6\x9d\xe2\x9b\xb2\xd1\xd6\x43\x4b\x8b" \ + "\x29\xae\x77\x5a\xd8\xc2\xe4\x8c\x53\x91" +#define EMPTY_BLOB_SHA256_BIN_LITERAL \ + "\x47\x3a\x0f\x4c\x3b\xe8\xa9\x36\x81\xa2" \ + "\x67\xe3\xb1\xe9\xa7\xdc\xda\x11\x85\x43" \ + "\x6f\xe1\x41\xf7\x74\x91\x20\xa3\x03\x72" \ + "\x18\x13" + +const struct object_id null_oid; +static const struct object_id empty_tree_oid = { + EMPTY_TREE_SHA1_BIN_LITERAL +}; +static const struct object_id empty_blob_oid = { + EMPTY_BLOB_SHA1_BIN_LITERAL +}; +static const struct object_id empty_tree_oid_sha256 = { + EMPTY_TREE_SHA256_BIN_LITERAL +}; +static const struct object_id empty_blob_oid_sha256 = { + EMPTY_BLOB_SHA256_BIN_LITERAL +}; + +static void git_hash_sha1_init(git_hash_ctx *ctx) +{ + git_SHA1_Init(&ctx->sha1); +} + +static void git_hash_sha1_clone(git_hash_ctx *dst, const git_hash_ctx *src) +{ + git_SHA1_Clone(&dst->sha1, &src->sha1); +} + +static void git_hash_sha1_update(git_hash_ctx *ctx, const void *data, size_t len) +{ + git_SHA1_Update(&ctx->sha1, data, len); +} + +static void git_hash_sha1_final(unsigned char *hash, git_hash_ctx *ctx) +{ + git_SHA1_Final(hash, &ctx->sha1); +} + + +static void git_hash_sha256_init(git_hash_ctx *ctx) +{ + git_SHA256_Init(&ctx->sha256); +} + +static void git_hash_sha256_clone(git_hash_ctx *dst, const git_hash_ctx *src) +{ + git_SHA256_Clone(&dst->sha256, &src->sha256); +} + +static void git_hash_sha256_update(git_hash_ctx *ctx, const void *data, size_t len) +{ + git_SHA256_Update(&ctx->sha256, data, len); +} + +static void git_hash_sha256_final(unsigned char *hash, git_hash_ctx *ctx) +{ + git_SHA256_Final(hash, &ctx->sha256); +} + +static void git_hash_unknown_init(git_hash_ctx *ctx) +{ + BUG("trying to init unknown hash"); +} + +static void git_hash_unknown_clone(git_hash_ctx *dst, const git_hash_ctx *src) +{ + BUG("trying to clone unknown hash"); +} + +static void git_hash_unknown_update(git_hash_ctx *ctx, const void *data, size_t len) +{ + BUG("trying to update unknown hash"); +} + +static void git_hash_unknown_final(unsigned char *hash, git_hash_ctx *ctx) +{ + BUG("trying to finalize unknown hash"); +} + +const struct git_hash_algo hash_algos[GIT_HASH_NALGOS] = { + { + NULL, + 0x00000000, + 0, + 0, + 0, + git_hash_unknown_init, + git_hash_unknown_clone, + git_hash_unknown_update, + git_hash_unknown_final, + NULL, + NULL, + }, + { + "sha1", + /* "sha1", big-endian */ + 0x73686131, + GIT_SHA1_RAWSZ, + GIT_SHA1_HEXSZ, + GIT_SHA1_BLKSZ, + git_hash_sha1_init, + git_hash_sha1_clone, + git_hash_sha1_update, + git_hash_sha1_final, + &empty_tree_oid, + &empty_blob_oid, + }, + { + "sha256", + /* "s256", big-endian */ + 0x73323536, + GIT_SHA256_RAWSZ, + GIT_SHA256_HEXSZ, + GIT_SHA256_BLKSZ, + git_hash_sha256_init, + git_hash_sha256_clone, + git_hash_sha256_update, + git_hash_sha256_final, + &empty_tree_oid_sha256, + &empty_blob_oid_sha256, + } +}; + +const char *empty_tree_oid_hex(void) +{ + static char buf[GIT_MAX_HEXSZ + 1]; + return oid_to_hex_r(buf, the_hash_algo->empty_tree); +} + +const char *empty_blob_oid_hex(void) +{ + static char buf[GIT_MAX_HEXSZ + 1]; + return oid_to_hex_r(buf, the_hash_algo->empty_blob); +} + +int hash_algo_by_name(const char *name) +{ + int i; + if (!name) + return GIT_HASH_UNKNOWN; + for (i = 1; i < GIT_HASH_NALGOS; i++) + if (!strcmp(name, hash_algos[i].name)) + return i; + return GIT_HASH_UNKNOWN; +} + +int hash_algo_by_id(uint32_t format_id) +{ + int i; + for (i = 1; i < GIT_HASH_NALGOS; i++) + if (format_id == hash_algos[i].format_id) + return i; + return GIT_HASH_UNKNOWN; +} + +int hash_algo_by_length(int len) +{ + int i; + for (i = 1; i < GIT_HASH_NALGOS; i++) + if (len == hash_algos[i].rawsz) + return i; + return GIT_HASH_UNKNOWN; +} + +/* + * This is meant to hold a *small* number of objects that you would + * want read_object_file() to be able to return, but yet you do not want + * to write them into the object store (e.g. a browse-only + * application). + */ +static struct cached_object { + struct object_id oid; + enum object_type type; + void *buf; + unsigned long size; +} *cached_objects; +static int cached_object_nr, cached_object_alloc; + +static struct cached_object empty_tree = { + { EMPTY_TREE_SHA1_BIN_LITERAL }, + OBJ_TREE, + "", + 0 +}; + +static struct cached_object *find_cached_object(const struct object_id *oid) +{ + int i; + struct cached_object *co = cached_objects; + + for (i = 0; i < cached_object_nr; i++, co++) { + if (oideq(&co->oid, oid)) + return co; + } + if (oideq(oid, the_hash_algo->empty_tree)) + return &empty_tree; + return NULL; +} + + +static int get_conv_flags(unsigned flags) +{ + if (flags & HASH_RENORMALIZE) + return CONV_EOL_RENORMALIZE; + else if (flags & HASH_WRITE_OBJECT) + return global_conv_flags_eol | CONV_WRITE_OBJECT; + else + return 0; +} + + +int mkdir_in_gitdir(const char *path) +{ + if (mkdir(path, 0777)) { + int saved_errno = errno; + struct stat st; + struct strbuf sb = STRBUF_INIT; + + if (errno != EEXIST) + return -1; + /* + * Are we looking at a path in a symlinked worktree + * whose original repository does not yet have it? + * e.g. .git/rr-cache pointing at its original + * repository in which the user hasn't performed any + * conflict resolution yet? + */ + if (lstat(path, &st) || !S_ISLNK(st.st_mode) || + strbuf_readlink(&sb, path, st.st_size) || + !is_absolute_path(sb.buf) || + mkdir(sb.buf, 0777)) { + strbuf_release(&sb); + errno = saved_errno; + return -1; + } + strbuf_release(&sb); + } + return adjust_shared_perm(path); +} + +static enum scld_error safe_create_leading_directories_1(char *path, int share) +{ + char *next_component = path + offset_1st_component(path); + enum scld_error ret = SCLD_OK; + + while (ret == SCLD_OK && next_component) { + struct stat st; + char *slash = next_component, slash_character; + + while (*slash && !is_dir_sep(*slash)) + slash++; + + if (!*slash) + break; + + next_component = slash + 1; + while (is_dir_sep(*next_component)) + next_component++; + if (!*next_component) + break; + + slash_character = *slash; + *slash = '\0'; + if (!stat(path, &st)) { + /* path exists */ + if (!S_ISDIR(st.st_mode)) { + errno = ENOTDIR; + ret = SCLD_EXISTS; + } + } else if (mkdir(path, 0777)) { + if (errno == EEXIST && + !stat(path, &st) && S_ISDIR(st.st_mode)) + ; /* somebody created it since we checked */ + else if (errno == ENOENT) + /* + * Either mkdir() failed because + * somebody just pruned the containing + * directory, or stat() failed because + * the file that was in our way was + * just removed. Either way, inform + * the caller that it might be worth + * trying again: + */ + ret = SCLD_VANISHED; + else + ret = SCLD_FAILED; + } else if (share && adjust_shared_perm(path)) { + ret = SCLD_PERMS; + } + *slash = slash_character; + } + return ret; +} + +enum scld_error safe_create_leading_directories(char *path) +{ + return safe_create_leading_directories_1(path, 1); +} + +enum scld_error safe_create_leading_directories_no_share(char *path) +{ + return safe_create_leading_directories_1(path, 0); +} + +enum scld_error safe_create_leading_directories_const(const char *path) +{ + int save_errno; + /* path points to cache entries, so xstrdup before messing with it */ + char *buf = xstrdup(path); + enum scld_error result = safe_create_leading_directories(buf); + + save_errno = errno; + free(buf); + errno = save_errno; + return result; +} + +int raceproof_create_file(const char *path, create_file_fn fn, void *cb) +{ + /* + * The number of times we will try to remove empty directories + * in the way of path. This is only 1 because if another + * process is racily creating directories that conflict with + * us, we don't want to fight against them. + */ + int remove_directories_remaining = 1; + + /* + * The number of times that we will try to create the + * directories containing path. We are willing to attempt this + * more than once, because another process could be trying to + * clean up empty directories at the same time as we are + * trying to create them. + */ + int create_directories_remaining = 3; + + /* A scratch copy of path, filled lazily if we need it: */ + struct strbuf path_copy = STRBUF_INIT; + + int ret, save_errno; + + /* Sanity check: */ + assert(*path); + +retry_fn: + ret = fn(path, cb); + save_errno = errno; + if (!ret) + goto out; + + if (errno == EISDIR && remove_directories_remaining-- > 0) { + /* + * A directory is in the way. Maybe it is empty; try + * to remove it: + */ + if (!path_copy.len) + strbuf_addstr(&path_copy, path); + + if (!remove_dir_recursively(&path_copy, REMOVE_DIR_EMPTY_ONLY)) + goto retry_fn; + } else if (errno == ENOENT && create_directories_remaining-- > 0) { + /* + * Maybe the containing directory didn't exist, or + * maybe it was just deleted by a process that is + * racing with us to clean up empty directories. Try + * to create it: + */ + enum scld_error scld_result; + + if (!path_copy.len) + strbuf_addstr(&path_copy, path); + + do { + scld_result = safe_create_leading_directories(path_copy.buf); + if (scld_result == SCLD_OK) + goto retry_fn; + } while (scld_result == SCLD_VANISHED && create_directories_remaining-- > 0); + } + +out: + strbuf_release(&path_copy); + errno = save_errno; + return ret; +} + +static void fill_loose_path(struct strbuf *buf, const struct object_id *oid) +{ + int i; + for (i = 0; i < the_hash_algo->rawsz; i++) { + static char hex[] = "0123456789abcdef"; + unsigned int val = oid->hash[i]; + strbuf_addch(buf, hex[val >> 4]); + strbuf_addch(buf, hex[val & 0xf]); + if (!i) + strbuf_addch(buf, '/'); + } +} + +static const char *odb_loose_path(struct object_directory *odb, + struct strbuf *buf, + const struct object_id *oid) +{ + strbuf_reset(buf); + strbuf_addstr(buf, odb->path); + strbuf_addch(buf, '/'); + fill_loose_path(buf, oid); + return buf->buf; +} + +const char *loose_object_path(struct repository *r, struct strbuf *buf, + const struct object_id *oid) +{ + return odb_loose_path(r->objects->odb, buf, oid); +} + +/* + * Return non-zero iff the path is usable as an alternate object database. + */ +static int alt_odb_usable(struct raw_object_store *o, + struct strbuf *path, + const char *normalized_objdir) +{ + struct object_directory *odb; + + /* Detect cases where alternate disappeared */ + if (!is_directory(path->buf)) { + error(_("object directory %s does not exist; " + "check .git/objects/info/alternates"), + path->buf); + return 0; + } + + /* + * Prevent the common mistake of listing the same + * thing twice, or object directory itself. + */ + for (odb = o->odb; odb; odb = odb->next) { + if (!fspathcmp(path->buf, odb->path)) + return 0; + } + if (!fspathcmp(path->buf, normalized_objdir)) + return 0; + + return 1; +} + +/* + * Prepare alternate object database registry. + * + * The variable alt_odb_list points at the list of struct + * object_directory. The elements on this list come from + * non-empty elements from colon separated ALTERNATE_DB_ENVIRONMENT + * environment variable, and $GIT_OBJECT_DIRECTORY/info/alternates, + * whose contents is similar to that environment variable but can be + * LF separated. Its base points at a statically allocated buffer that + * contains "/the/directory/corresponding/to/.git/objects/...", while + * its name points just after the slash at the end of ".git/objects/" + * in the example above, and has enough space to hold all hex characters + * of the object ID, an extra slash for the first level indirection, and + * the terminating NUL. + */ +static void read_info_alternates(struct repository *r, + const char *relative_base, + int depth); +static int link_alt_odb_entry(struct repository *r, const char *entry, + const char *relative_base, int depth, const char *normalized_objdir) +{ + struct object_directory *ent; + struct strbuf pathbuf = STRBUF_INIT; + + if (!is_absolute_path(entry) && relative_base) { + strbuf_realpath(&pathbuf, relative_base, 1); + strbuf_addch(&pathbuf, '/'); + } + strbuf_addstr(&pathbuf, entry); + + if (strbuf_normalize_path(&pathbuf) < 0 && relative_base) { + error(_("unable to normalize alternate object path: %s"), + pathbuf.buf); + strbuf_release(&pathbuf); + return -1; + } + + /* + * The trailing slash after the directory name is given by + * this function at the end. Remove duplicates. + */ + while (pathbuf.len && pathbuf.buf[pathbuf.len - 1] == '/') + strbuf_setlen(&pathbuf, pathbuf.len - 1); + + if (!alt_odb_usable(r->objects, &pathbuf, normalized_objdir)) { + strbuf_release(&pathbuf); + return -1; + } + + ent = xcalloc(1, sizeof(*ent)); + ent->path = xstrdup(pathbuf.buf); + + /* add the alternate entry */ + *r->objects->odb_tail = ent; + r->objects->odb_tail = &(ent->next); + ent->next = NULL; + + /* recursively add alternates */ + read_info_alternates(r, pathbuf.buf, depth + 1); + + strbuf_release(&pathbuf); + return 0; +} + +static const char *parse_alt_odb_entry(const char *string, + int sep, + struct strbuf *out) +{ + const char *end; + + strbuf_reset(out); + + if (*string == '#') { + /* comment; consume up to next separator */ + end = strchrnul(string, sep); + } else if (*string == '"' && !unquote_c_style(out, string, &end)) { + /* + * quoted path; unquote_c_style has copied the + * data for us and set "end". Broken quoting (e.g., + * an entry that doesn't end with a quote) falls + * back to the unquoted case below. + */ + } else { + /* normal, unquoted path */ + end = strchrnul(string, sep); + strbuf_add(out, string, end - string); + } + + if (*end) + end++; + return end; +} + +static void link_alt_odb_entries(struct repository *r, const char *alt, + int sep, const char *relative_base, int depth) +{ + struct strbuf objdirbuf = STRBUF_INIT; + struct strbuf entry = STRBUF_INIT; + + if (!alt || !*alt) + return; + + if (depth > 5) { + error(_("%s: ignoring alternate object stores, nesting too deep"), + relative_base); + return; + } + + strbuf_add_absolute_path(&objdirbuf, r->objects->odb->path); + if (strbuf_normalize_path(&objdirbuf) < 0) + die(_("unable to normalize object directory: %s"), + objdirbuf.buf); + + while (*alt) { + alt = parse_alt_odb_entry(alt, sep, &entry); + if (!entry.len) + continue; + link_alt_odb_entry(r, entry.buf, + relative_base, depth, objdirbuf.buf); + } + strbuf_release(&entry); + strbuf_release(&objdirbuf); +} + +static void read_info_alternates(struct repository *r, + const char *relative_base, + int depth) +{ + char *path; + struct strbuf buf = STRBUF_INIT; + + path = xstrfmt("%s/info/alternates", relative_base); + if (strbuf_read_file(&buf, path, 1024) < 0) { + warn_on_fopen_errors(path); + free(path); + return; + } + + link_alt_odb_entries(r, buf.buf, '\n', relative_base, depth); + strbuf_release(&buf); + free(path); +} + +void add_to_alternates_file(const char *reference) +{ + struct lock_file lock = LOCK_INIT; + char *alts = git_pathdup("objects/info/alternates"); + FILE *in, *out; + int found = 0; + + hold_lock_file_for_update(&lock, alts, LOCK_DIE_ON_ERROR); + out = fdopen_lock_file(&lock, "w"); + if (!out) + die_errno(_("unable to fdopen alternates lockfile")); + + in = fopen(alts, "r"); + if (in) { + struct strbuf line = STRBUF_INIT; + + while (strbuf_getline(&line, in) != EOF) { + if (!strcmp(reference, line.buf)) { + found = 1; + break; + } + fprintf_or_die(out, "%s\n", line.buf); + } + + strbuf_release(&line); + fclose(in); + } + else if (errno != ENOENT) + die_errno(_("unable to read alternates file")); + + if (found) { + rollback_lock_file(&lock); + } else { + fprintf_or_die(out, "%s\n", reference); + if (commit_lock_file(&lock)) + die_errno(_("unable to move new alternates file into place")); + if (the_repository->objects->loaded_alternates) + link_alt_odb_entries(the_repository, reference, + '\n', NULL, 0); + } + free(alts); +} + +void add_to_alternates_memory(const char *reference) +{ + /* + * Make sure alternates are initialized, or else our entry may be + * overwritten when they are. + */ + prepare_alt_odb(the_repository); + + link_alt_odb_entries(the_repository, reference, + '\n', NULL, 0); +} + +/* + * Compute the exact path an alternate is at and returns it. In case of + * error NULL is returned and the human readable error is added to `err` + * `path` may be relative and should point to $GIT_DIR. + * `err` must not be null. + */ +char *compute_alternate_path(const char *path, struct strbuf *err) +{ + char *ref_git = NULL; + const char *repo; + int seen_error = 0; + + ref_git = real_pathdup(path, 0); + if (!ref_git) { + seen_error = 1; + strbuf_addf(err, _("path '%s' does not exist"), path); + goto out; + } + + repo = read_gitfile(ref_git); + if (!repo) + repo = read_gitfile(mkpath("%s/.git", ref_git)); + if (repo) { + free(ref_git); + ref_git = xstrdup(repo); + } + + if (!repo && is_directory(mkpath("%s/.git/objects", ref_git))) { + char *ref_git_git = mkpathdup("%s/.git", ref_git); + free(ref_git); + ref_git = ref_git_git; + } else if (!is_directory(mkpath("%s/objects", ref_git))) { + struct strbuf sb = STRBUF_INIT; + seen_error = 1; + if (get_common_dir(&sb, ref_git)) { + strbuf_addf(err, + _("reference repository '%s' as a linked " + "checkout is not supported yet."), + path); + goto out; + } + + strbuf_addf(err, _("reference repository '%s' is not a " + "local repository."), path); + goto out; + } + + if (!access(mkpath("%s/shallow", ref_git), F_OK)) { + strbuf_addf(err, _("reference repository '%s' is shallow"), + path); + seen_error = 1; + goto out; + } + + if (!access(mkpath("%s/info/grafts", ref_git), F_OK)) { + strbuf_addf(err, + _("reference repository '%s' is grafted"), + path); + seen_error = 1; + goto out; + } + +out: + if (seen_error) { + FREE_AND_NULL(ref_git); + } + + return ref_git; +} + +static void fill_alternate_refs_command(struct child_process *cmd, + const char *repo_path) +{ + const char *value; + + if (!git_config_get_value("core.alternateRefsCommand", &value)) { + cmd->use_shell = 1; + + strvec_push(&cmd->args, value); + strvec_push(&cmd->args, repo_path); + } else { + cmd->git_cmd = 1; + + strvec_pushf(&cmd->args, "--git-dir=%s", repo_path); + strvec_push(&cmd->args, "for-each-ref"); + strvec_push(&cmd->args, "--format=%(objectname)"); + + if (!git_config_get_value("core.alternateRefsPrefixes", &value)) { + strvec_push(&cmd->args, "--"); + strvec_split(&cmd->args, value); + } + } + + cmd->env = local_repo_env; + cmd->out = -1; +} + +static void read_alternate_refs(const char *path, + alternate_ref_fn *cb, + void *data) +{ + struct child_process cmd = CHILD_PROCESS_INIT; + struct strbuf line = STRBUF_INIT; + FILE *fh; + + fill_alternate_refs_command(&cmd, path); + + if (start_command(&cmd)) + return; + + fh = xfdopen(cmd.out, "r"); + while (strbuf_getline_lf(&line, fh) != EOF) { + struct object_id oid; + const char *p; + + if (parse_oid_hex(line.buf, &oid, &p) || *p) { + warning(_("invalid line while parsing alternate refs: %s"), + line.buf); + break; + } + + cb(&oid, data); + } + + fclose(fh); + finish_command(&cmd); + strbuf_release(&line); +} + +struct alternate_refs_data { + alternate_ref_fn *fn; + void *data; +}; + +static int refs_from_alternate_cb(struct object_directory *e, + void *data) +{ + struct strbuf path = STRBUF_INIT; + size_t base_len; + struct alternate_refs_data *cb = data; + + if (!strbuf_realpath(&path, e->path, 0)) + goto out; + if (!strbuf_strip_suffix(&path, "/objects")) + goto out; + base_len = path.len; + + /* Is this a git repository with refs? */ + strbuf_addstr(&path, "/refs"); + if (!is_directory(path.buf)) + goto out; + strbuf_setlen(&path, base_len); + + read_alternate_refs(path.buf, cb->fn, cb->data); + +out: + strbuf_release(&path); + return 0; +} + +void for_each_alternate_ref(alternate_ref_fn fn, void *data) +{ + struct alternate_refs_data cb; + cb.fn = fn; + cb.data = data; + foreach_alt_odb(refs_from_alternate_cb, &cb); +} + +int foreach_alt_odb(alt_odb_fn fn, void *cb) +{ + struct object_directory *ent; + int r = 0; + + prepare_alt_odb(the_repository); + for (ent = the_repository->objects->odb->next; ent; ent = ent->next) { + r = fn(ent, cb); + if (r) + break; + } + return r; +} + +void prepare_alt_odb(struct repository *r) +{ + if (r->objects->loaded_alternates) + return; + + link_alt_odb_entries(r, r->objects->alternate_db, PATH_SEP, NULL, 0); + + read_info_alternates(r, r->objects->odb->path, 0); + r->objects->loaded_alternates = 1; +} + +/* Returns 1 if we have successfully freshened the file, 0 otherwise. */ +static int freshen_file(const char *fn) +{ + return !utime(fn, NULL); +} + +/* + * All of the check_and_freshen functions return 1 if the file exists and was + * freshened (if freshening was requested), 0 otherwise. If they return + * 0, you should not assume that it is safe to skip a write of the object (it + * either does not exist on disk, or has a stale mtime and may be subject to + * pruning). + */ +int check_and_freshen_file(const char *fn, int freshen) +{ + if (access(fn, F_OK)) + return 0; + if (freshen && !freshen_file(fn)) + return 0; + return 1; +} + +static int check_and_freshen_odb(struct object_directory *odb, + const struct object_id *oid, + int freshen) +{ + static struct strbuf path = STRBUF_INIT; + odb_loose_path(odb, &path, oid); + return check_and_freshen_file(path.buf, freshen); +} + +static int check_and_freshen_local(const struct object_id *oid, int freshen) +{ + return check_and_freshen_odb(the_repository->objects->odb, oid, freshen); +} + +static int check_and_freshen_nonlocal(const struct object_id *oid, int freshen) +{ + struct object_directory *odb; + + prepare_alt_odb(the_repository); + for (odb = the_repository->objects->odb->next; odb; odb = odb->next) { + if (check_and_freshen_odb(odb, oid, freshen)) + return 1; + } + return 0; +} + +static int check_and_freshen(const struct object_id *oid, int freshen) +{ + return check_and_freshen_local(oid, freshen) || + check_and_freshen_nonlocal(oid, freshen); +} + +int has_loose_object_nonlocal(const struct object_id *oid) +{ + return check_and_freshen_nonlocal(oid, 0); +} + +static int has_loose_object(const struct object_id *oid) +{ + return check_and_freshen(oid, 0); +} + +static void mmap_limit_check(size_t length) +{ + static size_t limit = 0; + if (!limit) { + limit = git_env_ulong("GIT_MMAP_LIMIT", 0); + if (!limit) + limit = SIZE_MAX; + } + if (length > limit) + die(_("attempting to mmap %"PRIuMAX" over limit %"PRIuMAX), + (uintmax_t)length, (uintmax_t)limit); +} + +void *xmmap_gently(void *start, size_t length, + int prot, int flags, int fd, off_t offset) +{ + void *ret; + + mmap_limit_check(length); + ret = mmap(start, length, prot, flags, fd, offset); + if (ret == MAP_FAILED && !length) + ret = NULL; + return ret; +} + +void *xmmap(void *start, size_t length, + int prot, int flags, int fd, off_t offset) +{ + void *ret = xmmap_gently(start, length, prot, flags, fd, offset); + if (ret == MAP_FAILED) + die_errno(_("mmap failed")); + return ret; +} + +/* + * With an in-core object data in "map", rehash it to make sure the + * object name actually matches "oid" to detect object corruption. + * With "map" == NULL, try reading the object named with "oid" using + * the streaming interface and rehash it to do the same. + */ +int check_object_signature(struct repository *r, const struct object_id *oid, + void *map, unsigned long size, const char *type) +{ + struct object_id real_oid; + enum object_type obj_type; + struct git_istream *st; + git_hash_ctx c; + char hdr[MAX_HEADER_LEN]; + int hdrlen; + + if (map) { + hash_object_file(r->hash_algo, map, size, type, &real_oid); + return !oideq(oid, &real_oid) ? -1 : 0; + } + + st = open_istream(r, oid, &obj_type, &size, NULL); + if (!st) + return -1; + + /* Generate the header */ + hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %"PRIuMAX , type_name(obj_type), (uintmax_t)size) + 1; + + /* Sha1.. */ + r->hash_algo->init_fn(&c); + r->hash_algo->update_fn(&c, hdr, hdrlen); + for (;;) { + char buf[1024 * 16]; + ssize_t readlen = read_istream(st, buf, sizeof(buf)); + + if (readlen < 0) { + close_istream(st); + return -1; + } + if (!readlen) + break; + r->hash_algo->update_fn(&c, buf, readlen); + } + r->hash_algo->final_fn(real_oid.hash, &c); + close_istream(st); + return !oideq(oid, &real_oid) ? -1 : 0; +} + +int git_open_cloexec(const char *name, int flags) +{ + int fd; + static int o_cloexec = O_CLOEXEC; + + fd = open(name, flags | o_cloexec); + if ((o_cloexec & O_CLOEXEC) && fd < 0 && errno == EINVAL) { + /* Try again w/o O_CLOEXEC: the kernel might not support it */ + o_cloexec &= ~O_CLOEXEC; + fd = open(name, flags | o_cloexec); + } + +#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC) + { + static int fd_cloexec = FD_CLOEXEC; + + if (!o_cloexec && 0 <= fd && fd_cloexec) { + /* Opened w/o O_CLOEXEC? try with fcntl(2) to add it */ + int flags = fcntl(fd, F_GETFD); + if (fcntl(fd, F_SETFD, flags | fd_cloexec)) + fd_cloexec = 0; + } + } +#endif + return fd; +} + +/* + * Find "oid" as a loose object in the local repository or in an alternate. + * Returns 0 on success, negative on failure. + * + * The "path" out-parameter will give the path of the object we found (if any). + * Note that it may point to static storage and is only valid until another + * call to stat_loose_object(). + */ +static int stat_loose_object(struct repository *r, const struct object_id *oid, + struct stat *st, const char **path) +{ + struct object_directory *odb; + static struct strbuf buf = STRBUF_INIT; + + prepare_alt_odb(r); + for (odb = r->objects->odb; odb; odb = odb->next) { + *path = odb_loose_path(odb, &buf, oid); + if (!lstat(*path, st)) + return 0; + } + + return -1; +} + +/* + * Like stat_loose_object(), but actually open the object and return the + * descriptor. See the caveats on the "path" parameter above. + */ +static int open_loose_object(struct repository *r, + const struct object_id *oid, const char **path) +{ + int fd; + struct object_directory *odb; + int most_interesting_errno = ENOENT; + static struct strbuf buf = STRBUF_INIT; + + prepare_alt_odb(r); + for (odb = r->objects->odb; odb; odb = odb->next) { + *path = odb_loose_path(odb, &buf, oid); + fd = git_open(*path); + if (fd >= 0) + return fd; + + if (most_interesting_errno == ENOENT) + most_interesting_errno = errno; + } + errno = most_interesting_errno; + return -1; +} + +static int quick_has_loose(struct repository *r, + const struct object_id *oid) +{ + struct object_directory *odb; + + prepare_alt_odb(r); + for (odb = r->objects->odb; odb; odb = odb->next) { + if (oid_array_lookup(odb_loose_cache(odb, oid), oid) >= 0) + return 1; + } + return 0; +} + +/* + * Map the loose object at "path" if it is not NULL, or the path found by + * searching for a loose object named "oid". + */ +static void *map_loose_object_1(struct repository *r, const char *path, + const struct object_id *oid, unsigned long *size) +{ + void *map; + int fd; + + if (path) + fd = git_open(path); + else + fd = open_loose_object(r, oid, &path); + map = NULL; + if (fd >= 0) { + struct stat st; + + if (!fstat(fd, &st)) { + *size = xsize_t(st.st_size); + if (!*size) { + /* mmap() is forbidden on empty files */ + error(_("object file %s is empty"), path); + close(fd); + return NULL; + } + map = xmmap(NULL, *size, PROT_READ, MAP_PRIVATE, fd, 0); + } + close(fd); + } + return map; +} + +void *map_loose_object(struct repository *r, + const struct object_id *oid, + unsigned long *size) +{ + return map_loose_object_1(r, NULL, oid, size); +} + +static int unpack_loose_short_header(git_zstream *stream, + unsigned char *map, unsigned long mapsize, + void *buffer, unsigned long bufsiz) +{ + int ret; + + /* Get the data stream */ + memset(stream, 0, sizeof(*stream)); + stream->next_in = map; + stream->avail_in = mapsize; + stream->next_out = buffer; + stream->avail_out = bufsiz; + + git_inflate_init(stream); + obj_read_unlock(); + ret = git_inflate(stream, 0); + obj_read_lock(); + + return ret; +} + +int unpack_loose_header(git_zstream *stream, + unsigned char *map, unsigned long mapsize, + void *buffer, unsigned long bufsiz) +{ + int status = unpack_loose_short_header(stream, map, mapsize, + buffer, bufsiz); + + if (status < Z_OK) + return status; + + /* Make sure we have the terminating NUL */ + if (!memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer)) + return -1; + return 0; +} + +static int unpack_loose_header_to_strbuf(git_zstream *stream, unsigned char *map, + unsigned long mapsize, void *buffer, + unsigned long bufsiz, struct strbuf *header) +{ + int status; + + status = unpack_loose_short_header(stream, map, mapsize, buffer, bufsiz); + if (status < Z_OK) + return -1; + + /* + * Check if entire header is unpacked in the first iteration. + */ + if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer)) + return 0; + + /* + * buffer[0..bufsiz] was not large enough. Copy the partial + * result out to header, and then append the result of further + * reading the stream. + */ + strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer); + stream->next_out = buffer; + stream->avail_out = bufsiz; + + do { + obj_read_unlock(); + status = git_inflate(stream, 0); + obj_read_lock(); + strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer); + if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer)) + return 0; + stream->next_out = buffer; + stream->avail_out = bufsiz; + } while (status != Z_STREAM_END); + return -1; +} + +static void *unpack_loose_rest(git_zstream *stream, + void *buffer, unsigned long size, + const struct object_id *oid) +{ + int bytes = strlen(buffer) + 1; + unsigned char *buf = xmallocz(size); + unsigned long n; + int status = Z_OK; + + n = stream->total_out - bytes; + if (n > size) + n = size; + memcpy(buf, (char *) buffer + bytes, n); + bytes = n; + if (bytes <= size) { + /* + * The above condition must be (bytes <= size), not + * (bytes < size). In other words, even though we + * expect no more output and set avail_out to zero, + * the input zlib stream may have bytes that express + * "this concludes the stream", and we *do* want to + * eat that input. + * + * Otherwise we would not be able to test that we + * consumed all the input to reach the expected size; + * we also want to check that zlib tells us that all + * went well with status == Z_STREAM_END at the end. + */ + stream->next_out = buf + bytes; + stream->avail_out = size - bytes; + while (status == Z_OK) { + obj_read_unlock(); + status = git_inflate(stream, Z_FINISH); + obj_read_lock(); + } + } + if (status == Z_STREAM_END && !stream->avail_in) { + git_inflate_end(stream); + return buf; + } + + if (status < 0) + error(_("corrupt loose object '%s'"), oid_to_hex(oid)); + else if (stream->avail_in) + error(_("garbage at end of loose object '%s'"), + oid_to_hex(oid)); + free(buf); + return NULL; +} + +/* + * We used to just use "sscanf()", but that's actually way + * too permissive for what we want to check. So do an anal + * object header parse by hand. + */ +static int parse_loose_header_extended(const char *hdr, struct object_info *oi, + unsigned int flags) +{ + const char *type_buf = hdr; + unsigned long size; + int type, type_len = 0; + + /* + * The type can be of any size but is followed by + * a space. + */ + for (;;) { + char c = *hdr++; + if (!c) + return -1; + if (c == ' ') + break; + type_len++; + } + + type = type_from_string_gently(type_buf, type_len, 1); + if (oi->type_name) + strbuf_add(oi->type_name, type_buf, type_len); + /* + * Set type to 0 if its an unknown object and + * we're obtaining the type using '--allow-unknown-type' + * option. + */ + if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE) && (type < 0)) + type = 0; + else if (type < 0) + die(_("invalid object type")); + if (oi->typep) + *oi->typep = type; + + /* + * The length must follow immediately, and be in canonical + * decimal format (ie "010" is not valid). + */ + size = *hdr++ - '0'; + if (size > 9) + return -1; + if (size) { + for (;;) { + unsigned long c = *hdr - '0'; + if (c > 9) + break; + hdr++; + size = size * 10 + c; + } + } + + if (oi->sizep) + *oi->sizep = size; + + /* + * The length must be followed by a zero byte + */ + return *hdr ? -1 : type; +} + +int parse_loose_header(const char *hdr, unsigned long *sizep) +{ + struct object_info oi = OBJECT_INFO_INIT; + + oi.sizep = sizep; + return parse_loose_header_extended(hdr, &oi, 0); +} + +static int loose_object_info(struct repository *r, + const struct object_id *oid, + struct object_info *oi, int flags) +{ + int status = 0; + unsigned long mapsize; + void *map; + git_zstream stream; + char hdr[MAX_HEADER_LEN]; + struct strbuf hdrbuf = STRBUF_INIT; + unsigned long size_scratch; + + if (oi->delta_base_oid) + oidclr(oi->delta_base_oid); + + /* + * If we don't care about type or size, then we don't + * need to look inside the object at all. Note that we + * do not optimize out the stat call, even if the + * caller doesn't care about the disk-size, since our + * return value implicitly indicates whether the + * object even exists. + */ + if (!oi->typep && !oi->type_name && !oi->sizep && !oi->contentp) { + const char *path; + struct stat st; + if (!oi->disk_sizep && (flags & OBJECT_INFO_QUICK)) + return quick_has_loose(r, oid) ? 0 : -1; + if (stat_loose_object(r, oid, &st, &path) < 0) + return -1; + if (oi->disk_sizep) + *oi->disk_sizep = st.st_size; + return 0; + } + + map = map_loose_object(r, oid, &mapsize); + if (!map) + return -1; + + if (!oi->sizep) + oi->sizep = &size_scratch; + + if (oi->disk_sizep) + *oi->disk_sizep = mapsize; + if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE)) { + if (unpack_loose_header_to_strbuf(&stream, map, mapsize, hdr, sizeof(hdr), &hdrbuf) < 0) + status = error(_("unable to unpack %s header with --allow-unknown-type"), + oid_to_hex(oid)); + } else if (unpack_loose_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0) + status = error(_("unable to unpack %s header"), + oid_to_hex(oid)); + if (status < 0) + ; /* Do nothing */ + else if (hdrbuf.len) { + if ((status = parse_loose_header_extended(hdrbuf.buf, oi, flags)) < 0) + status = error(_("unable to parse %s header with --allow-unknown-type"), + oid_to_hex(oid)); + } else if ((status = parse_loose_header_extended(hdr, oi, flags)) < 0) + status = error(_("unable to parse %s header"), oid_to_hex(oid)); + + if (status >= 0 && oi->contentp) { + *oi->contentp = unpack_loose_rest(&stream, hdr, + *oi->sizep, oid); + if (!*oi->contentp) { + git_inflate_end(&stream); + status = -1; + } + } else + git_inflate_end(&stream); + + munmap(map, mapsize); + if (status && oi->typep) + *oi->typep = status; + if (oi->sizep == &size_scratch) + oi->sizep = NULL; + strbuf_release(&hdrbuf); + oi->whence = OI_LOOSE; + return (status < 0) ? status : 0; +} + +int obj_read_use_lock = 0; +pthread_mutex_t obj_read_mutex; + +void enable_obj_read_lock(void) +{ + if (obj_read_use_lock) + return; + + obj_read_use_lock = 1; + init_recursive_mutex(&obj_read_mutex); +} + +void disable_obj_read_lock(void) +{ + if (!obj_read_use_lock) + return; + + obj_read_use_lock = 0; + pthread_mutex_destroy(&obj_read_mutex); +} + +int fetch_if_missing = 1; + +static int do_oid_object_info_extended(struct repository *r, + const struct object_id *oid, + struct object_info *oi, unsigned flags) +{ + static struct object_info blank_oi = OBJECT_INFO_INIT; + struct cached_object *co; + struct pack_entry e; + int rtype; + const struct object_id *real = oid; + int already_retried = 0; + + + if (flags & OBJECT_INFO_LOOKUP_REPLACE) + real = lookup_replace_object(r, oid); + + if (is_null_oid(real)) + return -1; + + if (!oi) + oi = &blank_oi; + + co = find_cached_object(real); + if (co) { + if (oi->typep) + *(oi->typep) = co->type; + if (oi->sizep) + *(oi->sizep) = co->size; + if (oi->disk_sizep) + *(oi->disk_sizep) = 0; + if (oi->delta_base_oid) + oidclr(oi->delta_base_oid); + if (oi->type_name) + strbuf_addstr(oi->type_name, type_name(co->type)); + if (oi->contentp) + *oi->contentp = xmemdupz(co->buf, co->size); + oi->whence = OI_CACHED; + return 0; + } + + while (1) { + if (find_pack_entry(r, real, &e)) + break; + + if (flags & OBJECT_INFO_IGNORE_LOOSE) + return -1; + + /* Most likely it's a loose object. */ + if (!loose_object_info(r, real, oi, flags)) + return 0; + + /* Not a loose object; someone else may have just packed it. */ + if (!(flags & OBJECT_INFO_QUICK)) { + reprepare_packed_git(r); + if (find_pack_entry(r, real, &e)) + break; + } + + /* Check if it is a missing object */ + if (fetch_if_missing && has_promisor_remote() && + !already_retried && r == the_repository && + !(flags & OBJECT_INFO_SKIP_FETCH_OBJECT)) { + /* + * TODO Investigate checking promisor_remote_get_direct() + * TODO return value and stopping on error here. + * TODO Pass a repository struct through + * promisor_remote_get_direct(), such that arbitrary + * repositories work. + */ + promisor_remote_get_direct(r, real, 1); + already_retried = 1; + continue; + } + + return -1; + } + + if (oi == &blank_oi) + /* + * We know that the caller doesn't actually need the + * information below, so return early. + */ + return 0; + rtype = packed_object_info(r, e.p, e.offset, oi); + if (rtype < 0) { + mark_bad_packed_object(e.p, real->hash); + return do_oid_object_info_extended(r, real, oi, 0); + } else if (oi->whence == OI_PACKED) { + oi->u.packed.offset = e.offset; + oi->u.packed.pack = e.p; + oi->u.packed.is_delta = (rtype == OBJ_REF_DELTA || + rtype == OBJ_OFS_DELTA); + } + + return 0; +} + +int oid_object_info_extended(struct repository *r, const struct object_id *oid, + struct object_info *oi, unsigned flags) +{ + int ret; + obj_read_lock(); + ret = do_oid_object_info_extended(r, oid, oi, flags); + obj_read_unlock(); + return ret; +} + + +/* returns enum object_type or negative */ +int oid_object_info(struct repository *r, + const struct object_id *oid, + unsigned long *sizep) +{ + enum object_type type; + struct object_info oi = OBJECT_INFO_INIT; + + oi.typep = &type; + oi.sizep = sizep; + if (oid_object_info_extended(r, oid, &oi, + OBJECT_INFO_LOOKUP_REPLACE) < 0) + return -1; + return type; +} + +static void *read_object(struct repository *r, + const struct object_id *oid, enum object_type *type, + unsigned long *size) +{ + struct object_info oi = OBJECT_INFO_INIT; + void *content; + oi.typep = type; + oi.sizep = size; + oi.contentp = &content; + + if (oid_object_info_extended(r, oid, &oi, 0) < 0) + return NULL; + return content; +} + +int pretend_object_file(void *buf, unsigned long len, enum object_type type, + struct object_id *oid) +{ + struct cached_object *co; + + hash_object_file(the_hash_algo, buf, len, type_name(type), oid); + if (has_object_file_with_flags(oid, OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT) || + find_cached_object(oid)) + return 0; + ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc); + co = &cached_objects[cached_object_nr++]; + co->size = len; + co->type = type; + co->buf = xmalloc(len); + memcpy(co->buf, buf, len); + oidcpy(&co->oid, oid); + return 0; +} + +/* + * This function dies on corrupt objects; the callers who want to + * deal with them should arrange to call read_object() and give error + * messages themselves. + */ +void *read_object_file_extended(struct repository *r, + const struct object_id *oid, + enum object_type *type, + unsigned long *size, + int lookup_replace) +{ + void *data; + const struct packed_git *p; + const char *path; + struct stat st; + const struct object_id *repl = lookup_replace ? + lookup_replace_object(r, oid) : oid; + + errno = 0; + data = read_object(r, repl, type, size); + if (data) + return data; + + obj_read_lock(); + if (errno && errno != ENOENT) + die_errno(_("failed to read object %s"), oid_to_hex(oid)); + + /* die if we replaced an object with one that does not exist */ + if (repl != oid) + die(_("replacement %s not found for %s"), + oid_to_hex(repl), oid_to_hex(oid)); + + if (!stat_loose_object(r, repl, &st, &path)) + die(_("loose object %s (stored in %s) is corrupt"), + oid_to_hex(repl), path); + + if ((p = has_packed_and_bad(r, repl->hash)) != NULL) + die(_("packed object %s (stored in %s) is corrupt"), + oid_to_hex(repl), p->pack_name); + obj_read_unlock(); + + return NULL; +} + +void *read_object_with_reference(struct repository *r, + const struct object_id *oid, + const char *required_type_name, + unsigned long *size, + struct object_id *actual_oid_return) +{ + enum object_type type, required_type; + void *buffer; + unsigned long isize; + struct object_id actual_oid; + + required_type = type_from_string(required_type_name); + oidcpy(&actual_oid, oid); + while (1) { + int ref_length = -1; + const char *ref_type = NULL; + + buffer = repo_read_object_file(r, &actual_oid, &type, &isize); + if (!buffer) + return NULL; + if (type == required_type) { + *size = isize; + if (actual_oid_return) + oidcpy(actual_oid_return, &actual_oid); + return buffer; + } + /* Handle references */ + else if (type == OBJ_COMMIT) + ref_type = "tree "; + else if (type == OBJ_TAG) + ref_type = "object "; + else { + free(buffer); + return NULL; + } + ref_length = strlen(ref_type); + + if (ref_length + the_hash_algo->hexsz > isize || + memcmp(buffer, ref_type, ref_length) || + get_oid_hex((char *) buffer + ref_length, &actual_oid)) { + free(buffer); + return NULL; + } + free(buffer); + /* Now we have the ID of the referred-to object in + * actual_oid. Check again. */ + } +} + +static void write_object_file_prepare(const struct git_hash_algo *algo, + const void *buf, unsigned long len, + const char *type, struct object_id *oid, + char *hdr, int *hdrlen) +{ + git_hash_ctx c; + + /* Generate the header */ + *hdrlen = xsnprintf(hdr, *hdrlen, "%s %"PRIuMAX , type, (uintmax_t)len)+1; + + /* Sha1.. */ + algo->init_fn(&c); + algo->update_fn(&c, hdr, *hdrlen); + algo->update_fn(&c, buf, len); + algo->final_fn(oid->hash, &c); +} + +/* + * Move the just written object into its final resting place. + */ +int finalize_object_file(const char *tmpfile, const char *filename) +{ + int ret = 0; + + if (object_creation_mode == OBJECT_CREATION_USES_RENAMES) + goto try_rename; + else if (link(tmpfile, filename)) + ret = errno; + + /* + * Coda hack - coda doesn't like cross-directory links, + * so we fall back to a rename, which will mean that it + * won't be able to check collisions, but that's not a + * big deal. + * + * The same holds for FAT formatted media. + * + * When this succeeds, we just return. We have nothing + * left to unlink. + */ + if (ret && ret != EEXIST) { + try_rename: + if (!rename(tmpfile, filename)) + goto out; + ret = errno; + } + unlink_or_warn(tmpfile); + if (ret) { + if (ret != EEXIST) { + return error_errno(_("unable to write file %s"), filename); + } + /* FIXME!!! Collision check here ? */ + } + +out: + if (adjust_shared_perm(filename)) + return error(_("unable to set permission to '%s'"), filename); + return 0; +} + +static int write_buffer(int fd, const void *buf, size_t len) +{ + if (write_in_full(fd, buf, len) < 0) + return error_errno(_("file write error")); + return 0; +} + +int hash_object_file(const struct git_hash_algo *algo, const void *buf, + unsigned long len, const char *type, + struct object_id *oid) +{ + char hdr[MAX_HEADER_LEN]; + int hdrlen = sizeof(hdr); + write_object_file_prepare(algo, buf, len, type, oid, hdr, &hdrlen); + return 0; +} + +/* Finalize a file on disk, and close it. */ +static void close_loose_object(int fd) +{ + if (fsync_object_files) + fsync_or_die(fd, "loose object file"); + if (close(fd) != 0) + die_errno(_("error when closing loose object file")); +} + +/* Size of directory component, including the ending '/' */ +static inline int directory_size(const char *filename) +{ + const char *s = strrchr(filename, '/'); + if (!s) + return 0; + return s - filename + 1; +} + +/* + * This creates a temporary file in the same directory as the final + * 'filename' + * + * We want to avoid cross-directory filename renames, because those + * can have problems on various filesystems (FAT, NFS, Coda). + */ +static int create_tmpfile(struct strbuf *tmp, const char *filename) +{ + int fd, dirlen = directory_size(filename); + + strbuf_reset(tmp); + strbuf_add(tmp, filename, dirlen); + strbuf_addstr(tmp, "tmp_obj_XXXXXX"); + fd = git_mkstemp_mode(tmp->buf, 0444); + if (fd < 0 && dirlen && errno == ENOENT) { + /* + * Make sure the directory exists; note that the contents + * of the buffer are undefined after mkstemp returns an + * error, so we have to rewrite the whole buffer from + * scratch. + */ + strbuf_reset(tmp); + strbuf_add(tmp, filename, dirlen - 1); + if (mkdir(tmp->buf, 0777) && errno != EEXIST) + return -1; + if (adjust_shared_perm(tmp->buf)) + return -1; + + /* Try again */ + strbuf_addstr(tmp, "/tmp_obj_XXXXXX"); + fd = git_mkstemp_mode(tmp->buf, 0444); + } + return fd; +} + +static int write_loose_object(const struct object_id *oid, char *hdr, + int hdrlen, const void *buf, unsigned long len, + time_t mtime) +{ + int fd, ret; + unsigned char compressed[4096]; + git_zstream stream; + git_hash_ctx c; + struct object_id parano_oid; + static struct strbuf tmp_file = STRBUF_INIT; + static struct strbuf filename = STRBUF_INIT; + + loose_object_path(the_repository, &filename, oid); + + fd = create_tmpfile(&tmp_file, filename.buf); + if (fd < 0) { + if (errno == EACCES) + return error(_("insufficient permission for adding an object to repository database %s"), get_object_directory()); + else + return error_errno(_("unable to create temporary file")); + } + + /* Set it up */ + git_deflate_init(&stream, zlib_compression_level); + stream.next_out = compressed; + stream.avail_out = sizeof(compressed); + the_hash_algo->init_fn(&c); + + /* First header.. */ + stream.next_in = (unsigned char *)hdr; + stream.avail_in = hdrlen; + while (git_deflate(&stream, 0) == Z_OK) + ; /* nothing */ + the_hash_algo->update_fn(&c, hdr, hdrlen); + + /* Then the data itself.. */ + stream.next_in = (void *)buf; + stream.avail_in = len; + do { + unsigned char *in0 = stream.next_in; + ret = git_deflate(&stream, Z_FINISH); + the_hash_algo->update_fn(&c, in0, stream.next_in - in0); + if (write_buffer(fd, compressed, stream.next_out - compressed) < 0) + die(_("unable to write loose object file")); + stream.next_out = compressed; + stream.avail_out = sizeof(compressed); + } while (ret == Z_OK); + + if (ret != Z_STREAM_END) + die(_("unable to deflate new object %s (%d)"), oid_to_hex(oid), + ret); + ret = git_deflate_end_gently(&stream); + if (ret != Z_OK) + die(_("deflateEnd on object %s failed (%d)"), oid_to_hex(oid), + ret); + the_hash_algo->final_fn(parano_oid.hash, &c); + if (!oideq(oid, ¶no_oid)) + die(_("confused by unstable object source data for %s"), + oid_to_hex(oid)); + + close_loose_object(fd); + + if (mtime) { + struct utimbuf utb; + utb.actime = mtime; + utb.modtime = mtime; + if (utime(tmp_file.buf, &utb) < 0) + warning_errno(_("failed utime() on %s"), tmp_file.buf); + } + + return finalize_object_file(tmp_file.buf, filename.buf); +} + +static int freshen_loose_object(const struct object_id *oid) +{ + return check_and_freshen(oid, 1); +} + +static int freshen_packed_object(const struct object_id *oid) +{ + struct pack_entry e; + if (!find_pack_entry(the_repository, oid, &e)) + return 0; + if (e.p->freshened) + return 1; + if (!freshen_file(e.p->pack_name)) + return 0; + e.p->freshened = 1; + return 1; +} + +int write_object_file(const void *buf, unsigned long len, const char *type, + struct object_id *oid) +{ + char hdr[MAX_HEADER_LEN]; + int hdrlen = sizeof(hdr); + + /* Normally if we have it in the pack then we do not bother writing + * it out into .git/objects/??/?{38} file. + */ + write_object_file_prepare(the_hash_algo, buf, len, type, oid, hdr, + &hdrlen); + if (freshen_packed_object(oid) || freshen_loose_object(oid)) + return 0; + return write_loose_object(oid, hdr, hdrlen, buf, len, 0); +} + +int hash_object_file_literally(const void *buf, unsigned long len, + const char *type, struct object_id *oid, + unsigned flags) +{ + char *header; + int hdrlen, status = 0; + + /* type string, SP, %lu of the length plus NUL must fit this */ + hdrlen = strlen(type) + MAX_HEADER_LEN; + header = xmalloc(hdrlen); + write_object_file_prepare(the_hash_algo, buf, len, type, oid, header, + &hdrlen); + + if (!(flags & HASH_WRITE_OBJECT)) + goto cleanup; + if (freshen_packed_object(oid) || freshen_loose_object(oid)) + goto cleanup; + status = write_loose_object(oid, header, hdrlen, buf, len, 0); + +cleanup: + free(header); + return status; +} + +int force_object_loose(const struct object_id *oid, time_t mtime) +{ + void *buf; + unsigned long len; + enum object_type type; + char hdr[MAX_HEADER_LEN]; + int hdrlen; + int ret; + + if (has_loose_object(oid)) + return 0; + buf = read_object(the_repository, oid, &type, &len); + if (!buf) + return error(_("cannot read object for %s"), oid_to_hex(oid)); + hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %"PRIuMAX , type_name(type), (uintmax_t)len) + 1; + ret = write_loose_object(oid, hdr, hdrlen, buf, len, mtime); + free(buf); + + return ret; +} + +int has_object(struct repository *r, const struct object_id *oid, + unsigned flags) +{ + int quick = !(flags & HAS_OBJECT_RECHECK_PACKED); + unsigned object_info_flags = OBJECT_INFO_SKIP_FETCH_OBJECT | + (quick ? OBJECT_INFO_QUICK : 0); + + if (!startup_info->have_repository) + return 0; + return oid_object_info_extended(r, oid, NULL, object_info_flags) >= 0; +} + +int repo_has_object_file_with_flags(struct repository *r, + const struct object_id *oid, int flags) +{ + if (!startup_info->have_repository) + return 0; + return oid_object_info_extended(r, oid, NULL, flags) >= 0; +} + +int repo_has_object_file(struct repository *r, + const struct object_id *oid) +{ + return repo_has_object_file_with_flags(r, oid, 0); +} + +static void check_tree(const void *buf, size_t size) +{ + struct tree_desc desc; + struct name_entry entry; + + init_tree_desc(&desc, buf, size); + while (tree_entry(&desc, &entry)) + /* do nothing + * tree_entry() will die() on malformed entries */ + ; +} + +static void check_commit(const void *buf, size_t size) +{ + struct commit c; + memset(&c, 0, sizeof(c)); + if (parse_commit_buffer(the_repository, &c, buf, size, 0)) + die(_("corrupt commit")); +} + +static void check_tag(const void *buf, size_t size) +{ + struct tag t; + memset(&t, 0, sizeof(t)); + if (parse_tag_buffer(the_repository, &t, buf, size)) + die(_("corrupt tag")); +} + +static int index_mem(struct index_state *istate, + struct object_id *oid, void *buf, size_t size, + enum object_type type, + const char *path, unsigned flags) +{ + int ret, re_allocated = 0; + int write_object = flags & HASH_WRITE_OBJECT; + + if (!type) + type = OBJ_BLOB; + + /* + * Convert blobs to git internal format + */ + if ((type == OBJ_BLOB) && path) { + struct strbuf nbuf = STRBUF_INIT; + if (convert_to_git(istate, path, buf, size, &nbuf, + get_conv_flags(flags))) { + buf = strbuf_detach(&nbuf, &size); + re_allocated = 1; + } + } + if (flags & HASH_FORMAT_CHECK) { + if (type == OBJ_TREE) + check_tree(buf, size); + if (type == OBJ_COMMIT) + check_commit(buf, size); + if (type == OBJ_TAG) + check_tag(buf, size); + } + + if (write_object) + ret = write_object_file(buf, size, type_name(type), oid); + else + ret = hash_object_file(the_hash_algo, buf, size, + type_name(type), oid); + if (re_allocated) + free(buf); + return ret; +} + +static int index_stream_convert_blob(struct index_state *istate, + struct object_id *oid, + int fd, + const char *path, + unsigned flags) +{ + int ret; + const int write_object = flags & HASH_WRITE_OBJECT; + struct strbuf sbuf = STRBUF_INIT; + + assert(path); + assert(would_convert_to_git_filter_fd(istate, path)); + + convert_to_git_filter_fd(istate, path, fd, &sbuf, + get_conv_flags(flags)); + + if (write_object) + ret = write_object_file(sbuf.buf, sbuf.len, type_name(OBJ_BLOB), + oid); + else + ret = hash_object_file(the_hash_algo, sbuf.buf, sbuf.len, + type_name(OBJ_BLOB), oid); + strbuf_release(&sbuf); + return ret; +} + +static int index_pipe(struct index_state *istate, struct object_id *oid, + int fd, enum object_type type, + const char *path, unsigned flags) +{ + struct strbuf sbuf = STRBUF_INIT; + int ret; + + if (strbuf_read(&sbuf, fd, 4096) >= 0) + ret = index_mem(istate, oid, sbuf.buf, sbuf.len, type, path, flags); + else + ret = -1; + strbuf_release(&sbuf); + return ret; +} + +#define SMALL_FILE_SIZE (32*1024) + +static int index_core(struct index_state *istate, + struct object_id *oid, int fd, size_t size, + enum object_type type, const char *path, + unsigned flags) +{ + int ret; + + if (!size) { + ret = index_mem(istate, oid, "", size, type, path, flags); + } else if (size <= SMALL_FILE_SIZE) { + char *buf = xmalloc(size); + ssize_t read_result = read_in_full(fd, buf, size); + if (read_result < 0) + ret = error_errno(_("read error while indexing %s"), + path ? path : ""); + else if (read_result != size) + ret = error(_("short read while indexing %s"), + path ? path : ""); + else + ret = index_mem(istate, oid, buf, size, type, path, flags); + free(buf); + } else { + void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); + ret = index_mem(istate, oid, buf, size, type, path, flags); + munmap(buf, size); + } + return ret; +} + +/* + * This creates one packfile per large blob unless bulk-checkin + * machinery is "plugged". + * + * This also bypasses the usual "convert-to-git" dance, and that is on + * purpose. We could write a streaming version of the converting + * functions and insert that before feeding the data to fast-import + * (or equivalent in-core API described above). However, that is + * somewhat complicated, as we do not know the size of the filter + * result, which we need to know beforehand when writing a git object. + * Since the primary motivation for trying to stream from the working + * tree file and to avoid mmaping it in core is to deal with large + * binary blobs, they generally do not want to get any conversion, and + * callers should avoid this code path when filters are requested. + */ +static int index_stream(struct object_id *oid, int fd, size_t size, + enum object_type type, const char *path, + unsigned flags) +{ + return index_bulk_checkin(oid, fd, size, type, path, flags); +} + +int index_fd(struct index_state *istate, struct object_id *oid, + int fd, struct stat *st, + enum object_type type, const char *path, unsigned flags) +{ + int ret; + + /* + * Call xsize_t() only when needed to avoid potentially unnecessary + * die() for large files. + */ + if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(istate, path)) + ret = index_stream_convert_blob(istate, oid, fd, path, flags); + else if (!S_ISREG(st->st_mode)) + ret = index_pipe(istate, oid, fd, type, path, flags); + else if (st->st_size <= big_file_threshold || type != OBJ_BLOB || + (path && would_convert_to_git(istate, path))) + ret = index_core(istate, oid, fd, xsize_t(st->st_size), + type, path, flags); + else + ret = index_stream(oid, fd, xsize_t(st->st_size), type, path, + flags); + close(fd); + return ret; +} + +int index_path(struct index_state *istate, struct object_id *oid, + const char *path, struct stat *st, unsigned flags) +{ + int fd; + struct strbuf sb = STRBUF_INIT; + int rc = 0; + + switch (st->st_mode & S_IFMT) { + case S_IFREG: + fd = open(path, O_RDONLY); + if (fd < 0) + return error_errno("open(\"%s\")", path); + if (index_fd(istate, oid, fd, st, OBJ_BLOB, path, flags) < 0) + return error(_("%s: failed to insert into database"), + path); + break; + case S_IFLNK: + if (strbuf_readlink(&sb, path, st->st_size)) + return error_errno("readlink(\"%s\")", path); + if (!(flags & HASH_WRITE_OBJECT)) + hash_object_file(the_hash_algo, sb.buf, sb.len, + blob_type, oid); + else if (write_object_file(sb.buf, sb.len, blob_type, oid)) + rc = error(_("%s: failed to insert into database"), path); + strbuf_release(&sb); + break; + case S_IFDIR: + return resolve_gitlink_ref(path, "HEAD", oid); + default: + return error(_("%s: unsupported file type"), path); + } + return rc; +} + +int read_pack_header(int fd, struct pack_header *header) +{ + if (read_in_full(fd, header, sizeof(*header)) != sizeof(*header)) + /* "eof before pack header was fully read" */ + return PH_ERROR_EOF; + + if (header->hdr_signature != htonl(PACK_SIGNATURE)) + /* "protocol error (pack signature mismatch detected)" */ + return PH_ERROR_PACK_SIGNATURE; + if (!pack_version_ok(header->hdr_version)) + /* "protocol error (pack version unsupported)" */ + return PH_ERROR_PROTOCOL; + return 0; +} + +void assert_oid_type(const struct object_id *oid, enum object_type expect) +{ + enum object_type type = oid_object_info(the_repository, oid, NULL); + if (type < 0) + die(_("%s is not a valid object"), oid_to_hex(oid)); + if (type != expect) + die(_("%s is not a valid '%s' object"), oid_to_hex(oid), + type_name(expect)); +} + +int for_each_file_in_obj_subdir(unsigned int subdir_nr, + struct strbuf *path, + each_loose_object_fn obj_cb, + each_loose_cruft_fn cruft_cb, + each_loose_subdir_fn subdir_cb, + void *data) +{ + size_t origlen, baselen; + DIR *dir; + struct dirent *de; + int r = 0; + struct object_id oid; + + if (subdir_nr > 0xff) + BUG("invalid loose object subdirectory: %x", subdir_nr); + + origlen = path->len; + strbuf_complete(path, '/'); + strbuf_addf(path, "%02x", subdir_nr); + + dir = opendir(path->buf); + if (!dir) { + if (errno != ENOENT) + r = error_errno(_("unable to open %s"), path->buf); + strbuf_setlen(path, origlen); + return r; + } + + oid.hash[0] = subdir_nr; + strbuf_addch(path, '/'); + baselen = path->len; + + while ((de = readdir(dir))) { + size_t namelen; + if (is_dot_or_dotdot(de->d_name)) + continue; + + namelen = strlen(de->d_name); + strbuf_setlen(path, baselen); + strbuf_add(path, de->d_name, namelen); + if (namelen == the_hash_algo->hexsz - 2 && + !hex_to_bytes(oid.hash + 1, de->d_name, + the_hash_algo->rawsz - 1)) { + if (obj_cb) { + r = obj_cb(&oid, path->buf, data); + if (r) + break; + } + continue; + } + + if (cruft_cb) { + r = cruft_cb(de->d_name, path->buf, data); + if (r) + break; + } + } + closedir(dir); + + strbuf_setlen(path, baselen - 1); + if (!r && subdir_cb) + r = subdir_cb(subdir_nr, path->buf, data); + + strbuf_setlen(path, origlen); + + return r; +} + +int for_each_loose_file_in_objdir_buf(struct strbuf *path, + each_loose_object_fn obj_cb, + each_loose_cruft_fn cruft_cb, + each_loose_subdir_fn subdir_cb, + void *data) +{ + int r = 0; + int i; + + for (i = 0; i < 256; i++) { + r = for_each_file_in_obj_subdir(i, path, obj_cb, cruft_cb, + subdir_cb, data); + if (r) + break; + } + + return r; +} + +int for_each_loose_file_in_objdir(const char *path, + each_loose_object_fn obj_cb, + each_loose_cruft_fn cruft_cb, + each_loose_subdir_fn subdir_cb, + void *data) +{ + struct strbuf buf = STRBUF_INIT; + int r; + + strbuf_addstr(&buf, path); + r = for_each_loose_file_in_objdir_buf(&buf, obj_cb, cruft_cb, + subdir_cb, data); + strbuf_release(&buf); + + return r; +} + +int for_each_loose_object(each_loose_object_fn cb, void *data, + enum for_each_object_flags flags) +{ + struct object_directory *odb; + + prepare_alt_odb(the_repository); + for (odb = the_repository->objects->odb; odb; odb = odb->next) { + int r = for_each_loose_file_in_objdir(odb->path, cb, NULL, + NULL, data); + if (r) + return r; + + if (flags & FOR_EACH_OBJECT_LOCAL_ONLY) + break; + } + + return 0; +} + +static int append_loose_object(const struct object_id *oid, const char *path, + void *data) +{ + oid_array_append(data, oid); + return 0; +} + +struct oid_array *odb_loose_cache(struct object_directory *odb, + const struct object_id *oid) +{ + int subdir_nr = oid->hash[0]; + struct strbuf buf = STRBUF_INIT; + + if (subdir_nr < 0 || + subdir_nr >= ARRAY_SIZE(odb->loose_objects_subdir_seen)) + BUG("subdir_nr out of range"); + + if (odb->loose_objects_subdir_seen[subdir_nr]) + return &odb->loose_objects_cache[subdir_nr]; + + strbuf_addstr(&buf, odb->path); + for_each_file_in_obj_subdir(subdir_nr, &buf, + append_loose_object, + NULL, NULL, + &odb->loose_objects_cache[subdir_nr]); + odb->loose_objects_subdir_seen[subdir_nr] = 1; + strbuf_release(&buf); + return &odb->loose_objects_cache[subdir_nr]; +} + +void odb_clear_loose_cache(struct object_directory *odb) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(odb->loose_objects_cache); i++) + oid_array_clear(&odb->loose_objects_cache[i]); + memset(&odb->loose_objects_subdir_seen, 0, + sizeof(odb->loose_objects_subdir_seen)); +} + +static int check_stream_oid(git_zstream *stream, + const char *hdr, + unsigned long size, + const char *path, + const struct object_id *expected_oid) +{ + git_hash_ctx c; + struct object_id real_oid; + unsigned char buf[4096]; + unsigned long total_read; + int status = Z_OK; + + the_hash_algo->init_fn(&c); + the_hash_algo->update_fn(&c, hdr, stream->total_out); + + /* + * We already read some bytes into hdr, but the ones up to the NUL + * do not count against the object's content size. + */ + total_read = stream->total_out - strlen(hdr) - 1; + + /* + * This size comparison must be "<=" to read the final zlib packets; + * see the comment in unpack_loose_rest for details. + */ + while (total_read <= size && + (status == Z_OK || + (status == Z_BUF_ERROR && !stream->avail_out))) { + stream->next_out = buf; + stream->avail_out = sizeof(buf); + if (size - total_read < stream->avail_out) + stream->avail_out = size - total_read; + status = git_inflate(stream, Z_FINISH); + the_hash_algo->update_fn(&c, buf, stream->next_out - buf); + total_read += stream->next_out - buf; + } + git_inflate_end(stream); + + if (status != Z_STREAM_END) { + error(_("corrupt loose object '%s'"), oid_to_hex(expected_oid)); + return -1; + } + if (stream->avail_in) { + error(_("garbage at end of loose object '%s'"), + oid_to_hex(expected_oid)); + return -1; + } + + the_hash_algo->final_fn(real_oid.hash, &c); + if (!oideq(expected_oid, &real_oid)) { + error(_("hash mismatch for %s (expected %s)"), path, + oid_to_hex(expected_oid)); + return -1; + } + + return 0; +} + +int read_loose_object(const char *path, + const struct object_id *expected_oid, + enum object_type *type, + unsigned long *size, + void **contents) +{ + int ret = -1; + void *map = NULL; + unsigned long mapsize; + git_zstream stream; + char hdr[MAX_HEADER_LEN]; + + *contents = NULL; + + map = map_loose_object_1(the_repository, path, NULL, &mapsize); + if (!map) { + error_errno(_("unable to mmap %s"), path); + goto out; + } + + if (unpack_loose_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0) { + error(_("unable to unpack header of %s"), path); + goto out; + } + + *type = parse_loose_header(hdr, size); + if (*type < 0) { + error(_("unable to parse header of %s"), path); + git_inflate_end(&stream); + goto out; + } + + if (*type == OBJ_BLOB && *size > big_file_threshold) { + if (check_stream_oid(&stream, hdr, *size, path, expected_oid) < 0) + goto out; + } else { + *contents = unpack_loose_rest(&stream, hdr, *size, expected_oid); + if (!*contents) { + error(_("unable to unpack contents of %s"), path); + git_inflate_end(&stream); + goto out; + } + if (check_object_signature(the_repository, expected_oid, + *contents, *size, + type_name(*type))) { + error(_("hash mismatch for %s (expected %s)"), path, + oid_to_hex(expected_oid)); + free(*contents); + goto out; + } + } + + ret = 0; /* everything checks out */ + +out: + if (map) + munmap(map, mapsize); + return ret; +} diff --git a/sha1-file.c b/sha1-file.c deleted file mode 100644 index c3c49d2fa5..0000000000 --- a/sha1-file.c +++ /dev/null @@ -1,2554 +0,0 @@ -/* - * GIT - The information manager from hell - * - * Copyright (C) Linus Torvalds, 2005 - * - * This handles basic git sha1 object files - packing, unpacking, - * creation etc. - */ -#include "cache.h" -#include "config.h" -#include "string-list.h" -#include "lockfile.h" -#include "delta.h" -#include "pack.h" -#include "blob.h" -#include "commit.h" -#include "run-command.h" -#include "tag.h" -#include "tree.h" -#include "tree-walk.h" -#include "refs.h" -#include "pack-revindex.h" -#include "sha1-lookup.h" -#include "bulk-checkin.h" -#include "repository.h" -#include "replace-object.h" -#include "streaming.h" -#include "dir.h" -#include "list.h" -#include "mergesort.h" -#include "quote.h" -#include "packfile.h" -#include "object-store.h" -#include "promisor-remote.h" - -/* The maximum size for an object header. */ -#define MAX_HEADER_LEN 32 - - -#define EMPTY_TREE_SHA1_BIN_LITERAL \ - "\x4b\x82\x5d\xc6\x42\xcb\x6e\xb9\xa0\x60" \ - "\xe5\x4b\xf8\xd6\x92\x88\xfb\xee\x49\x04" -#define EMPTY_TREE_SHA256_BIN_LITERAL \ - "\x6e\xf1\x9b\x41\x22\x5c\x53\x69\xf1\xc1" \ - "\x04\xd4\x5d\x8d\x85\xef\xa9\xb0\x57\xb5" \ - "\x3b\x14\xb4\xb9\xb9\x39\xdd\x74\xde\xcc" \ - "\x53\x21" - -#define EMPTY_BLOB_SHA1_BIN_LITERAL \ - "\xe6\x9d\xe2\x9b\xb2\xd1\xd6\x43\x4b\x8b" \ - "\x29\xae\x77\x5a\xd8\xc2\xe4\x8c\x53\x91" -#define EMPTY_BLOB_SHA256_BIN_LITERAL \ - "\x47\x3a\x0f\x4c\x3b\xe8\xa9\x36\x81\xa2" \ - "\x67\xe3\xb1\xe9\xa7\xdc\xda\x11\x85\x43" \ - "\x6f\xe1\x41\xf7\x74\x91\x20\xa3\x03\x72" \ - "\x18\x13" - -const struct object_id null_oid; -static const struct object_id empty_tree_oid = { - EMPTY_TREE_SHA1_BIN_LITERAL -}; -static const struct object_id empty_blob_oid = { - EMPTY_BLOB_SHA1_BIN_LITERAL -}; -static const struct object_id empty_tree_oid_sha256 = { - EMPTY_TREE_SHA256_BIN_LITERAL -}; -static const struct object_id empty_blob_oid_sha256 = { - EMPTY_BLOB_SHA256_BIN_LITERAL -}; - -static void git_hash_sha1_init(git_hash_ctx *ctx) -{ - git_SHA1_Init(&ctx->sha1); -} - -static void git_hash_sha1_clone(git_hash_ctx *dst, const git_hash_ctx *src) -{ - git_SHA1_Clone(&dst->sha1, &src->sha1); -} - -static void git_hash_sha1_update(git_hash_ctx *ctx, const void *data, size_t len) -{ - git_SHA1_Update(&ctx->sha1, data, len); -} - -static void git_hash_sha1_final(unsigned char *hash, git_hash_ctx *ctx) -{ - git_SHA1_Final(hash, &ctx->sha1); -} - - -static void git_hash_sha256_init(git_hash_ctx *ctx) -{ - git_SHA256_Init(&ctx->sha256); -} - -static void git_hash_sha256_clone(git_hash_ctx *dst, const git_hash_ctx *src) -{ - git_SHA256_Clone(&dst->sha256, &src->sha256); -} - -static void git_hash_sha256_update(git_hash_ctx *ctx, const void *data, size_t len) -{ - git_SHA256_Update(&ctx->sha256, data, len); -} - -static void git_hash_sha256_final(unsigned char *hash, git_hash_ctx *ctx) -{ - git_SHA256_Final(hash, &ctx->sha256); -} - -static void git_hash_unknown_init(git_hash_ctx *ctx) -{ - BUG("trying to init unknown hash"); -} - -static void git_hash_unknown_clone(git_hash_ctx *dst, const git_hash_ctx *src) -{ - BUG("trying to clone unknown hash"); -} - -static void git_hash_unknown_update(git_hash_ctx *ctx, const void *data, size_t len) -{ - BUG("trying to update unknown hash"); -} - -static void git_hash_unknown_final(unsigned char *hash, git_hash_ctx *ctx) -{ - BUG("trying to finalize unknown hash"); -} - -const struct git_hash_algo hash_algos[GIT_HASH_NALGOS] = { - { - NULL, - 0x00000000, - 0, - 0, - 0, - git_hash_unknown_init, - git_hash_unknown_clone, - git_hash_unknown_update, - git_hash_unknown_final, - NULL, - NULL, - }, - { - "sha1", - /* "sha1", big-endian */ - 0x73686131, - GIT_SHA1_RAWSZ, - GIT_SHA1_HEXSZ, - GIT_SHA1_BLKSZ, - git_hash_sha1_init, - git_hash_sha1_clone, - git_hash_sha1_update, - git_hash_sha1_final, - &empty_tree_oid, - &empty_blob_oid, - }, - { - "sha256", - /* "s256", big-endian */ - 0x73323536, - GIT_SHA256_RAWSZ, - GIT_SHA256_HEXSZ, - GIT_SHA256_BLKSZ, - git_hash_sha256_init, - git_hash_sha256_clone, - git_hash_sha256_update, - git_hash_sha256_final, - &empty_tree_oid_sha256, - &empty_blob_oid_sha256, - } -}; - -const char *empty_tree_oid_hex(void) -{ - static char buf[GIT_MAX_HEXSZ + 1]; - return oid_to_hex_r(buf, the_hash_algo->empty_tree); -} - -const char *empty_blob_oid_hex(void) -{ - static char buf[GIT_MAX_HEXSZ + 1]; - return oid_to_hex_r(buf, the_hash_algo->empty_blob); -} - -int hash_algo_by_name(const char *name) -{ - int i; - if (!name) - return GIT_HASH_UNKNOWN; - for (i = 1; i < GIT_HASH_NALGOS; i++) - if (!strcmp(name, hash_algos[i].name)) - return i; - return GIT_HASH_UNKNOWN; -} - -int hash_algo_by_id(uint32_t format_id) -{ - int i; - for (i = 1; i < GIT_HASH_NALGOS; i++) - if (format_id == hash_algos[i].format_id) - return i; - return GIT_HASH_UNKNOWN; -} - -int hash_algo_by_length(int len) -{ - int i; - for (i = 1; i < GIT_HASH_NALGOS; i++) - if (len == hash_algos[i].rawsz) - return i; - return GIT_HASH_UNKNOWN; -} - -/* - * This is meant to hold a *small* number of objects that you would - * want read_object_file() to be able to return, but yet you do not want - * to write them into the object store (e.g. a browse-only - * application). - */ -static struct cached_object { - struct object_id oid; - enum object_type type; - void *buf; - unsigned long size; -} *cached_objects; -static int cached_object_nr, cached_object_alloc; - -static struct cached_object empty_tree = { - { EMPTY_TREE_SHA1_BIN_LITERAL }, - OBJ_TREE, - "", - 0 -}; - -static struct cached_object *find_cached_object(const struct object_id *oid) -{ - int i; - struct cached_object *co = cached_objects; - - for (i = 0; i < cached_object_nr; i++, co++) { - if (oideq(&co->oid, oid)) - return co; - } - if (oideq(oid, the_hash_algo->empty_tree)) - return &empty_tree; - return NULL; -} - - -static int get_conv_flags(unsigned flags) -{ - if (flags & HASH_RENORMALIZE) - return CONV_EOL_RENORMALIZE; - else if (flags & HASH_WRITE_OBJECT) - return global_conv_flags_eol | CONV_WRITE_OBJECT; - else - return 0; -} - - -int mkdir_in_gitdir(const char *path) -{ - if (mkdir(path, 0777)) { - int saved_errno = errno; - struct stat st; - struct strbuf sb = STRBUF_INIT; - - if (errno != EEXIST) - return -1; - /* - * Are we looking at a path in a symlinked worktree - * whose original repository does not yet have it? - * e.g. .git/rr-cache pointing at its original - * repository in which the user hasn't performed any - * conflict resolution yet? - */ - if (lstat(path, &st) || !S_ISLNK(st.st_mode) || - strbuf_readlink(&sb, path, st.st_size) || - !is_absolute_path(sb.buf) || - mkdir(sb.buf, 0777)) { - strbuf_release(&sb); - errno = saved_errno; - return -1; - } - strbuf_release(&sb); - } - return adjust_shared_perm(path); -} - -static enum scld_error safe_create_leading_directories_1(char *path, int share) -{ - char *next_component = path + offset_1st_component(path); - enum scld_error ret = SCLD_OK; - - while (ret == SCLD_OK && next_component) { - struct stat st; - char *slash = next_component, slash_character; - - while (*slash && !is_dir_sep(*slash)) - slash++; - - if (!*slash) - break; - - next_component = slash + 1; - while (is_dir_sep(*next_component)) - next_component++; - if (!*next_component) - break; - - slash_character = *slash; - *slash = '\0'; - if (!stat(path, &st)) { - /* path exists */ - if (!S_ISDIR(st.st_mode)) { - errno = ENOTDIR; - ret = SCLD_EXISTS; - } - } else if (mkdir(path, 0777)) { - if (errno == EEXIST && - !stat(path, &st) && S_ISDIR(st.st_mode)) - ; /* somebody created it since we checked */ - else if (errno == ENOENT) - /* - * Either mkdir() failed because - * somebody just pruned the containing - * directory, or stat() failed because - * the file that was in our way was - * just removed. Either way, inform - * the caller that it might be worth - * trying again: - */ - ret = SCLD_VANISHED; - else - ret = SCLD_FAILED; - } else if (share && adjust_shared_perm(path)) { - ret = SCLD_PERMS; - } - *slash = slash_character; - } - return ret; -} - -enum scld_error safe_create_leading_directories(char *path) -{ - return safe_create_leading_directories_1(path, 1); -} - -enum scld_error safe_create_leading_directories_no_share(char *path) -{ - return safe_create_leading_directories_1(path, 0); -} - -enum scld_error safe_create_leading_directories_const(const char *path) -{ - int save_errno; - /* path points to cache entries, so xstrdup before messing with it */ - char *buf = xstrdup(path); - enum scld_error result = safe_create_leading_directories(buf); - - save_errno = errno; - free(buf); - errno = save_errno; - return result; -} - -int raceproof_create_file(const char *path, create_file_fn fn, void *cb) -{ - /* - * The number of times we will try to remove empty directories - * in the way of path. This is only 1 because if another - * process is racily creating directories that conflict with - * us, we don't want to fight against them. - */ - int remove_directories_remaining = 1; - - /* - * The number of times that we will try to create the - * directories containing path. We are willing to attempt this - * more than once, because another process could be trying to - * clean up empty directories at the same time as we are - * trying to create them. - */ - int create_directories_remaining = 3; - - /* A scratch copy of path, filled lazily if we need it: */ - struct strbuf path_copy = STRBUF_INIT; - - int ret, save_errno; - - /* Sanity check: */ - assert(*path); - -retry_fn: - ret = fn(path, cb); - save_errno = errno; - if (!ret) - goto out; - - if (errno == EISDIR && remove_directories_remaining-- > 0) { - /* - * A directory is in the way. Maybe it is empty; try - * to remove it: - */ - if (!path_copy.len) - strbuf_addstr(&path_copy, path); - - if (!remove_dir_recursively(&path_copy, REMOVE_DIR_EMPTY_ONLY)) - goto retry_fn; - } else if (errno == ENOENT && create_directories_remaining-- > 0) { - /* - * Maybe the containing directory didn't exist, or - * maybe it was just deleted by a process that is - * racing with us to clean up empty directories. Try - * to create it: - */ - enum scld_error scld_result; - - if (!path_copy.len) - strbuf_addstr(&path_copy, path); - - do { - scld_result = safe_create_leading_directories(path_copy.buf); - if (scld_result == SCLD_OK) - goto retry_fn; - } while (scld_result == SCLD_VANISHED && create_directories_remaining-- > 0); - } - -out: - strbuf_release(&path_copy); - errno = save_errno; - return ret; -} - -static void fill_loose_path(struct strbuf *buf, const struct object_id *oid) -{ - int i; - for (i = 0; i < the_hash_algo->rawsz; i++) { - static char hex[] = "0123456789abcdef"; - unsigned int val = oid->hash[i]; - strbuf_addch(buf, hex[val >> 4]); - strbuf_addch(buf, hex[val & 0xf]); - if (!i) - strbuf_addch(buf, '/'); - } -} - -static const char *odb_loose_path(struct object_directory *odb, - struct strbuf *buf, - const struct object_id *oid) -{ - strbuf_reset(buf); - strbuf_addstr(buf, odb->path); - strbuf_addch(buf, '/'); - fill_loose_path(buf, oid); - return buf->buf; -} - -const char *loose_object_path(struct repository *r, struct strbuf *buf, - const struct object_id *oid) -{ - return odb_loose_path(r->objects->odb, buf, oid); -} - -/* - * Return non-zero iff the path is usable as an alternate object database. - */ -static int alt_odb_usable(struct raw_object_store *o, - struct strbuf *path, - const char *normalized_objdir) -{ - struct object_directory *odb; - - /* Detect cases where alternate disappeared */ - if (!is_directory(path->buf)) { - error(_("object directory %s does not exist; " - "check .git/objects/info/alternates"), - path->buf); - return 0; - } - - /* - * Prevent the common mistake of listing the same - * thing twice, or object directory itself. - */ - for (odb = o->odb; odb; odb = odb->next) { - if (!fspathcmp(path->buf, odb->path)) - return 0; - } - if (!fspathcmp(path->buf, normalized_objdir)) - return 0; - - return 1; -} - -/* - * Prepare alternate object database registry. - * - * The variable alt_odb_list points at the list of struct - * object_directory. The elements on this list come from - * non-empty elements from colon separated ALTERNATE_DB_ENVIRONMENT - * environment variable, and $GIT_OBJECT_DIRECTORY/info/alternates, - * whose contents is similar to that environment variable but can be - * LF separated. Its base points at a statically allocated buffer that - * contains "/the/directory/corresponding/to/.git/objects/...", while - * its name points just after the slash at the end of ".git/objects/" - * in the example above, and has enough space to hold 40-byte hex - * SHA1, an extra slash for the first level indirection, and the - * terminating NUL. - */ -static void read_info_alternates(struct repository *r, - const char *relative_base, - int depth); -static int link_alt_odb_entry(struct repository *r, const char *entry, - const char *relative_base, int depth, const char *normalized_objdir) -{ - struct object_directory *ent; - struct strbuf pathbuf = STRBUF_INIT; - - if (!is_absolute_path(entry) && relative_base) { - strbuf_realpath(&pathbuf, relative_base, 1); - strbuf_addch(&pathbuf, '/'); - } - strbuf_addstr(&pathbuf, entry); - - if (strbuf_normalize_path(&pathbuf) < 0 && relative_base) { - error(_("unable to normalize alternate object path: %s"), - pathbuf.buf); - strbuf_release(&pathbuf); - return -1; - } - - /* - * The trailing slash after the directory name is given by - * this function at the end. Remove duplicates. - */ - while (pathbuf.len && pathbuf.buf[pathbuf.len - 1] == '/') - strbuf_setlen(&pathbuf, pathbuf.len - 1); - - if (!alt_odb_usable(r->objects, &pathbuf, normalized_objdir)) { - strbuf_release(&pathbuf); - return -1; - } - - ent = xcalloc(1, sizeof(*ent)); - ent->path = xstrdup(pathbuf.buf); - - /* add the alternate entry */ - *r->objects->odb_tail = ent; - r->objects->odb_tail = &(ent->next); - ent->next = NULL; - - /* recursively add alternates */ - read_info_alternates(r, pathbuf.buf, depth + 1); - - strbuf_release(&pathbuf); - return 0; -} - -static const char *parse_alt_odb_entry(const char *string, - int sep, - struct strbuf *out) -{ - const char *end; - - strbuf_reset(out); - - if (*string == '#') { - /* comment; consume up to next separator */ - end = strchrnul(string, sep); - } else if (*string == '"' && !unquote_c_style(out, string, &end)) { - /* - * quoted path; unquote_c_style has copied the - * data for us and set "end". Broken quoting (e.g., - * an entry that doesn't end with a quote) falls - * back to the unquoted case below. - */ - } else { - /* normal, unquoted path */ - end = strchrnul(string, sep); - strbuf_add(out, string, end - string); - } - - if (*end) - end++; - return end; -} - -static void link_alt_odb_entries(struct repository *r, const char *alt, - int sep, const char *relative_base, int depth) -{ - struct strbuf objdirbuf = STRBUF_INIT; - struct strbuf entry = STRBUF_INIT; - - if (!alt || !*alt) - return; - - if (depth > 5) { - error(_("%s: ignoring alternate object stores, nesting too deep"), - relative_base); - return; - } - - strbuf_add_absolute_path(&objdirbuf, r->objects->odb->path); - if (strbuf_normalize_path(&objdirbuf) < 0) - die(_("unable to normalize object directory: %s"), - objdirbuf.buf); - - while (*alt) { - alt = parse_alt_odb_entry(alt, sep, &entry); - if (!entry.len) - continue; - link_alt_odb_entry(r, entry.buf, - relative_base, depth, objdirbuf.buf); - } - strbuf_release(&entry); - strbuf_release(&objdirbuf); -} - -static void read_info_alternates(struct repository *r, - const char *relative_base, - int depth) -{ - char *path; - struct strbuf buf = STRBUF_INIT; - - path = xstrfmt("%s/info/alternates", relative_base); - if (strbuf_read_file(&buf, path, 1024) < 0) { - warn_on_fopen_errors(path); - free(path); - return; - } - - link_alt_odb_entries(r, buf.buf, '\n', relative_base, depth); - strbuf_release(&buf); - free(path); -} - -void add_to_alternates_file(const char *reference) -{ - struct lock_file lock = LOCK_INIT; - char *alts = git_pathdup("objects/info/alternates"); - FILE *in, *out; - int found = 0; - - hold_lock_file_for_update(&lock, alts, LOCK_DIE_ON_ERROR); - out = fdopen_lock_file(&lock, "w"); - if (!out) - die_errno(_("unable to fdopen alternates lockfile")); - - in = fopen(alts, "r"); - if (in) { - struct strbuf line = STRBUF_INIT; - - while (strbuf_getline(&line, in) != EOF) { - if (!strcmp(reference, line.buf)) { - found = 1; - break; - } - fprintf_or_die(out, "%s\n", line.buf); - } - - strbuf_release(&line); - fclose(in); - } - else if (errno != ENOENT) - die_errno(_("unable to read alternates file")); - - if (found) { - rollback_lock_file(&lock); - } else { - fprintf_or_die(out, "%s\n", reference); - if (commit_lock_file(&lock)) - die_errno(_("unable to move new alternates file into place")); - if (the_repository->objects->loaded_alternates) - link_alt_odb_entries(the_repository, reference, - '\n', NULL, 0); - } - free(alts); -} - -void add_to_alternates_memory(const char *reference) -{ - /* - * Make sure alternates are initialized, or else our entry may be - * overwritten when they are. - */ - prepare_alt_odb(the_repository); - - link_alt_odb_entries(the_repository, reference, - '\n', NULL, 0); -} - -/* - * Compute the exact path an alternate is at and returns it. In case of - * error NULL is returned and the human readable error is added to `err` - * `path` may be relative and should point to $GIT_DIR. - * `err` must not be null. - */ -char *compute_alternate_path(const char *path, struct strbuf *err) -{ - char *ref_git = NULL; - const char *repo; - int seen_error = 0; - - ref_git = real_pathdup(path, 0); - if (!ref_git) { - seen_error = 1; - strbuf_addf(err, _("path '%s' does not exist"), path); - goto out; - } - - repo = read_gitfile(ref_git); - if (!repo) - repo = read_gitfile(mkpath("%s/.git", ref_git)); - if (repo) { - free(ref_git); - ref_git = xstrdup(repo); - } - - if (!repo && is_directory(mkpath("%s/.git/objects", ref_git))) { - char *ref_git_git = mkpathdup("%s/.git", ref_git); - free(ref_git); - ref_git = ref_git_git; - } else if (!is_directory(mkpath("%s/objects", ref_git))) { - struct strbuf sb = STRBUF_INIT; - seen_error = 1; - if (get_common_dir(&sb, ref_git)) { - strbuf_addf(err, - _("reference repository '%s' as a linked " - "checkout is not supported yet."), - path); - goto out; - } - - strbuf_addf(err, _("reference repository '%s' is not a " - "local repository."), path); - goto out; - } - - if (!access(mkpath("%s/shallow", ref_git), F_OK)) { - strbuf_addf(err, _("reference repository '%s' is shallow"), - path); - seen_error = 1; - goto out; - } - - if (!access(mkpath("%s/info/grafts", ref_git), F_OK)) { - strbuf_addf(err, - _("reference repository '%s' is grafted"), - path); - seen_error = 1; - goto out; - } - -out: - if (seen_error) { - FREE_AND_NULL(ref_git); - } - - return ref_git; -} - -static void fill_alternate_refs_command(struct child_process *cmd, - const char *repo_path) -{ - const char *value; - - if (!git_config_get_value("core.alternateRefsCommand", &value)) { - cmd->use_shell = 1; - - strvec_push(&cmd->args, value); - strvec_push(&cmd->args, repo_path); - } else { - cmd->git_cmd = 1; - - strvec_pushf(&cmd->args, "--git-dir=%s", repo_path); - strvec_push(&cmd->args, "for-each-ref"); - strvec_push(&cmd->args, "--format=%(objectname)"); - - if (!git_config_get_value("core.alternateRefsPrefixes", &value)) { - strvec_push(&cmd->args, "--"); - strvec_split(&cmd->args, value); - } - } - - cmd->env = local_repo_env; - cmd->out = -1; -} - -static void read_alternate_refs(const char *path, - alternate_ref_fn *cb, - void *data) -{ - struct child_process cmd = CHILD_PROCESS_INIT; - struct strbuf line = STRBUF_INIT; - FILE *fh; - - fill_alternate_refs_command(&cmd, path); - - if (start_command(&cmd)) - return; - - fh = xfdopen(cmd.out, "r"); - while (strbuf_getline_lf(&line, fh) != EOF) { - struct object_id oid; - const char *p; - - if (parse_oid_hex(line.buf, &oid, &p) || *p) { - warning(_("invalid line while parsing alternate refs: %s"), - line.buf); - break; - } - - cb(&oid, data); - } - - fclose(fh); - finish_command(&cmd); - strbuf_release(&line); -} - -struct alternate_refs_data { - alternate_ref_fn *fn; - void *data; -}; - -static int refs_from_alternate_cb(struct object_directory *e, - void *data) -{ - struct strbuf path = STRBUF_INIT; - size_t base_len; - struct alternate_refs_data *cb = data; - - if (!strbuf_realpath(&path, e->path, 0)) - goto out; - if (!strbuf_strip_suffix(&path, "/objects")) - goto out; - base_len = path.len; - - /* Is this a git repository with refs? */ - strbuf_addstr(&path, "/refs"); - if (!is_directory(path.buf)) - goto out; - strbuf_setlen(&path, base_len); - - read_alternate_refs(path.buf, cb->fn, cb->data); - -out: - strbuf_release(&path); - return 0; -} - -void for_each_alternate_ref(alternate_ref_fn fn, void *data) -{ - struct alternate_refs_data cb; - cb.fn = fn; - cb.data = data; - foreach_alt_odb(refs_from_alternate_cb, &cb); -} - -int foreach_alt_odb(alt_odb_fn fn, void *cb) -{ - struct object_directory *ent; - int r = 0; - - prepare_alt_odb(the_repository); - for (ent = the_repository->objects->odb->next; ent; ent = ent->next) { - r = fn(ent, cb); - if (r) - break; - } - return r; -} - -void prepare_alt_odb(struct repository *r) -{ - if (r->objects->loaded_alternates) - return; - - link_alt_odb_entries(r, r->objects->alternate_db, PATH_SEP, NULL, 0); - - read_info_alternates(r, r->objects->odb->path, 0); - r->objects->loaded_alternates = 1; -} - -/* Returns 1 if we have successfully freshened the file, 0 otherwise. */ -static int freshen_file(const char *fn) -{ - return !utime(fn, NULL); -} - -/* - * All of the check_and_freshen functions return 1 if the file exists and was - * freshened (if freshening was requested), 0 otherwise. If they return - * 0, you should not assume that it is safe to skip a write of the object (it - * either does not exist on disk, or has a stale mtime and may be subject to - * pruning). - */ -int check_and_freshen_file(const char *fn, int freshen) -{ - if (access(fn, F_OK)) - return 0; - if (freshen && !freshen_file(fn)) - return 0; - return 1; -} - -static int check_and_freshen_odb(struct object_directory *odb, - const struct object_id *oid, - int freshen) -{ - static struct strbuf path = STRBUF_INIT; - odb_loose_path(odb, &path, oid); - return check_and_freshen_file(path.buf, freshen); -} - -static int check_and_freshen_local(const struct object_id *oid, int freshen) -{ - return check_and_freshen_odb(the_repository->objects->odb, oid, freshen); -} - -static int check_and_freshen_nonlocal(const struct object_id *oid, int freshen) -{ - struct object_directory *odb; - - prepare_alt_odb(the_repository); - for (odb = the_repository->objects->odb->next; odb; odb = odb->next) { - if (check_and_freshen_odb(odb, oid, freshen)) - return 1; - } - return 0; -} - -static int check_and_freshen(const struct object_id *oid, int freshen) -{ - return check_and_freshen_local(oid, freshen) || - check_and_freshen_nonlocal(oid, freshen); -} - -int has_loose_object_nonlocal(const struct object_id *oid) -{ - return check_and_freshen_nonlocal(oid, 0); -} - -static int has_loose_object(const struct object_id *oid) -{ - return check_and_freshen(oid, 0); -} - -static void mmap_limit_check(size_t length) -{ - static size_t limit = 0; - if (!limit) { - limit = git_env_ulong("GIT_MMAP_LIMIT", 0); - if (!limit) - limit = SIZE_MAX; - } - if (length > limit) - die(_("attempting to mmap %"PRIuMAX" over limit %"PRIuMAX), - (uintmax_t)length, (uintmax_t)limit); -} - -void *xmmap_gently(void *start, size_t length, - int prot, int flags, int fd, off_t offset) -{ - void *ret; - - mmap_limit_check(length); - ret = mmap(start, length, prot, flags, fd, offset); - if (ret == MAP_FAILED && !length) - ret = NULL; - return ret; -} - -void *xmmap(void *start, size_t length, - int prot, int flags, int fd, off_t offset) -{ - void *ret = xmmap_gently(start, length, prot, flags, fd, offset); - if (ret == MAP_FAILED) - die_errno(_("mmap failed")); - return ret; -} - -/* - * With an in-core object data in "map", rehash it to make sure the - * object name actually matches "oid" to detect object corruption. - * With "map" == NULL, try reading the object named with "oid" using - * the streaming interface and rehash it to do the same. - */ -int check_object_signature(struct repository *r, const struct object_id *oid, - void *map, unsigned long size, const char *type) -{ - struct object_id real_oid; - enum object_type obj_type; - struct git_istream *st; - git_hash_ctx c; - char hdr[MAX_HEADER_LEN]; - int hdrlen; - - if (map) { - hash_object_file(r->hash_algo, map, size, type, &real_oid); - return !oideq(oid, &real_oid) ? -1 : 0; - } - - st = open_istream(r, oid, &obj_type, &size, NULL); - if (!st) - return -1; - - /* Generate the header */ - hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %"PRIuMAX , type_name(obj_type), (uintmax_t)size) + 1; - - /* Sha1.. */ - r->hash_algo->init_fn(&c); - r->hash_algo->update_fn(&c, hdr, hdrlen); - for (;;) { - char buf[1024 * 16]; - ssize_t readlen = read_istream(st, buf, sizeof(buf)); - - if (readlen < 0) { - close_istream(st); - return -1; - } - if (!readlen) - break; - r->hash_algo->update_fn(&c, buf, readlen); - } - r->hash_algo->final_fn(real_oid.hash, &c); - close_istream(st); - return !oideq(oid, &real_oid) ? -1 : 0; -} - -int git_open_cloexec(const char *name, int flags) -{ - int fd; - static int o_cloexec = O_CLOEXEC; - - fd = open(name, flags | o_cloexec); - if ((o_cloexec & O_CLOEXEC) && fd < 0 && errno == EINVAL) { - /* Try again w/o O_CLOEXEC: the kernel might not support it */ - o_cloexec &= ~O_CLOEXEC; - fd = open(name, flags | o_cloexec); - } - -#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC) - { - static int fd_cloexec = FD_CLOEXEC; - - if (!o_cloexec && 0 <= fd && fd_cloexec) { - /* Opened w/o O_CLOEXEC? try with fcntl(2) to add it */ - int flags = fcntl(fd, F_GETFD); - if (fcntl(fd, F_SETFD, flags | fd_cloexec)) - fd_cloexec = 0; - } - } -#endif - return fd; -} - -/* - * Find "oid" as a loose object in the local repository or in an alternate. - * Returns 0 on success, negative on failure. - * - * The "path" out-parameter will give the path of the object we found (if any). - * Note that it may point to static storage and is only valid until another - * call to stat_loose_object(). - */ -static int stat_loose_object(struct repository *r, const struct object_id *oid, - struct stat *st, const char **path) -{ - struct object_directory *odb; - static struct strbuf buf = STRBUF_INIT; - - prepare_alt_odb(r); - for (odb = r->objects->odb; odb; odb = odb->next) { - *path = odb_loose_path(odb, &buf, oid); - if (!lstat(*path, st)) - return 0; - } - - return -1; -} - -/* - * Like stat_loose_object(), but actually open the object and return the - * descriptor. See the caveats on the "path" parameter above. - */ -static int open_loose_object(struct repository *r, - const struct object_id *oid, const char **path) -{ - int fd; - struct object_directory *odb; - int most_interesting_errno = ENOENT; - static struct strbuf buf = STRBUF_INIT; - - prepare_alt_odb(r); - for (odb = r->objects->odb; odb; odb = odb->next) { - *path = odb_loose_path(odb, &buf, oid); - fd = git_open(*path); - if (fd >= 0) - return fd; - - if (most_interesting_errno == ENOENT) - most_interesting_errno = errno; - } - errno = most_interesting_errno; - return -1; -} - -static int quick_has_loose(struct repository *r, - const struct object_id *oid) -{ - struct object_directory *odb; - - prepare_alt_odb(r); - for (odb = r->objects->odb; odb; odb = odb->next) { - if (oid_array_lookup(odb_loose_cache(odb, oid), oid) >= 0) - return 1; - } - return 0; -} - -/* - * Map the loose object at "path" if it is not NULL, or the path found by - * searching for a loose object named "oid". - */ -static void *map_loose_object_1(struct repository *r, const char *path, - const struct object_id *oid, unsigned long *size) -{ - void *map; - int fd; - - if (path) - fd = git_open(path); - else - fd = open_loose_object(r, oid, &path); - map = NULL; - if (fd >= 0) { - struct stat st; - - if (!fstat(fd, &st)) { - *size = xsize_t(st.st_size); - if (!*size) { - /* mmap() is forbidden on empty files */ - error(_("object file %s is empty"), path); - close(fd); - return NULL; - } - map = xmmap(NULL, *size, PROT_READ, MAP_PRIVATE, fd, 0); - } - close(fd); - } - return map; -} - -void *map_loose_object(struct repository *r, - const struct object_id *oid, - unsigned long *size) -{ - return map_loose_object_1(r, NULL, oid, size); -} - -static int unpack_loose_short_header(git_zstream *stream, - unsigned char *map, unsigned long mapsize, - void *buffer, unsigned long bufsiz) -{ - int ret; - - /* Get the data stream */ - memset(stream, 0, sizeof(*stream)); - stream->next_in = map; - stream->avail_in = mapsize; - stream->next_out = buffer; - stream->avail_out = bufsiz; - - git_inflate_init(stream); - obj_read_unlock(); - ret = git_inflate(stream, 0); - obj_read_lock(); - - return ret; -} - -int unpack_loose_header(git_zstream *stream, - unsigned char *map, unsigned long mapsize, - void *buffer, unsigned long bufsiz) -{ - int status = unpack_loose_short_header(stream, map, mapsize, - buffer, bufsiz); - - if (status < Z_OK) - return status; - - /* Make sure we have the terminating NUL */ - if (!memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer)) - return -1; - return 0; -} - -static int unpack_loose_header_to_strbuf(git_zstream *stream, unsigned char *map, - unsigned long mapsize, void *buffer, - unsigned long bufsiz, struct strbuf *header) -{ - int status; - - status = unpack_loose_short_header(stream, map, mapsize, buffer, bufsiz); - if (status < Z_OK) - return -1; - - /* - * Check if entire header is unpacked in the first iteration. - */ - if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer)) - return 0; - - /* - * buffer[0..bufsiz] was not large enough. Copy the partial - * result out to header, and then append the result of further - * reading the stream. - */ - strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer); - stream->next_out = buffer; - stream->avail_out = bufsiz; - - do { - obj_read_unlock(); - status = git_inflate(stream, 0); - obj_read_lock(); - strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer); - if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer)) - return 0; - stream->next_out = buffer; - stream->avail_out = bufsiz; - } while (status != Z_STREAM_END); - return -1; -} - -static void *unpack_loose_rest(git_zstream *stream, - void *buffer, unsigned long size, - const struct object_id *oid) -{ - int bytes = strlen(buffer) + 1; - unsigned char *buf = xmallocz(size); - unsigned long n; - int status = Z_OK; - - n = stream->total_out - bytes; - if (n > size) - n = size; - memcpy(buf, (char *) buffer + bytes, n); - bytes = n; - if (bytes <= size) { - /* - * The above condition must be (bytes <= size), not - * (bytes < size). In other words, even though we - * expect no more output and set avail_out to zero, - * the input zlib stream may have bytes that express - * "this concludes the stream", and we *do* want to - * eat that input. - * - * Otherwise we would not be able to test that we - * consumed all the input to reach the expected size; - * we also want to check that zlib tells us that all - * went well with status == Z_STREAM_END at the end. - */ - stream->next_out = buf + bytes; - stream->avail_out = size - bytes; - while (status == Z_OK) { - obj_read_unlock(); - status = git_inflate(stream, Z_FINISH); - obj_read_lock(); - } - } - if (status == Z_STREAM_END && !stream->avail_in) { - git_inflate_end(stream); - return buf; - } - - if (status < 0) - error(_("corrupt loose object '%s'"), oid_to_hex(oid)); - else if (stream->avail_in) - error(_("garbage at end of loose object '%s'"), - oid_to_hex(oid)); - free(buf); - return NULL; -} - -/* - * We used to just use "sscanf()", but that's actually way - * too permissive for what we want to check. So do an anal - * object header parse by hand. - */ -static int parse_loose_header_extended(const char *hdr, struct object_info *oi, - unsigned int flags) -{ - const char *type_buf = hdr; - unsigned long size; - int type, type_len = 0; - - /* - * The type can be of any size but is followed by - * a space. - */ - for (;;) { - char c = *hdr++; - if (!c) - return -1; - if (c == ' ') - break; - type_len++; - } - - type = type_from_string_gently(type_buf, type_len, 1); - if (oi->type_name) - strbuf_add(oi->type_name, type_buf, type_len); - /* - * Set type to 0 if its an unknown object and - * we're obtaining the type using '--allow-unknown-type' - * option. - */ - if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE) && (type < 0)) - type = 0; - else if (type < 0) - die(_("invalid object type")); - if (oi->typep) - *oi->typep = type; - - /* - * The length must follow immediately, and be in canonical - * decimal format (ie "010" is not valid). - */ - size = *hdr++ - '0'; - if (size > 9) - return -1; - if (size) { - for (;;) { - unsigned long c = *hdr - '0'; - if (c > 9) - break; - hdr++; - size = size * 10 + c; - } - } - - if (oi->sizep) - *oi->sizep = size; - - /* - * The length must be followed by a zero byte - */ - return *hdr ? -1 : type; -} - -int parse_loose_header(const char *hdr, unsigned long *sizep) -{ - struct object_info oi = OBJECT_INFO_INIT; - - oi.sizep = sizep; - return parse_loose_header_extended(hdr, &oi, 0); -} - -static int loose_object_info(struct repository *r, - const struct object_id *oid, - struct object_info *oi, int flags) -{ - int status = 0; - unsigned long mapsize; - void *map; - git_zstream stream; - char hdr[MAX_HEADER_LEN]; - struct strbuf hdrbuf = STRBUF_INIT; - unsigned long size_scratch; - - if (oi->delta_base_oid) - oidclr(oi->delta_base_oid); - - /* - * If we don't care about type or size, then we don't - * need to look inside the object at all. Note that we - * do not optimize out the stat call, even if the - * caller doesn't care about the disk-size, since our - * return value implicitly indicates whether the - * object even exists. - */ - if (!oi->typep && !oi->type_name && !oi->sizep && !oi->contentp) { - const char *path; - struct stat st; - if (!oi->disk_sizep && (flags & OBJECT_INFO_QUICK)) - return quick_has_loose(r, oid) ? 0 : -1; - if (stat_loose_object(r, oid, &st, &path) < 0) - return -1; - if (oi->disk_sizep) - *oi->disk_sizep = st.st_size; - return 0; - } - - map = map_loose_object(r, oid, &mapsize); - if (!map) - return -1; - - if (!oi->sizep) - oi->sizep = &size_scratch; - - if (oi->disk_sizep) - *oi->disk_sizep = mapsize; - if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE)) { - if (unpack_loose_header_to_strbuf(&stream, map, mapsize, hdr, sizeof(hdr), &hdrbuf) < 0) - status = error(_("unable to unpack %s header with --allow-unknown-type"), - oid_to_hex(oid)); - } else if (unpack_loose_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0) - status = error(_("unable to unpack %s header"), - oid_to_hex(oid)); - if (status < 0) - ; /* Do nothing */ - else if (hdrbuf.len) { - if ((status = parse_loose_header_extended(hdrbuf.buf, oi, flags)) < 0) - status = error(_("unable to parse %s header with --allow-unknown-type"), - oid_to_hex(oid)); - } else if ((status = parse_loose_header_extended(hdr, oi, flags)) < 0) - status = error(_("unable to parse %s header"), oid_to_hex(oid)); - - if (status >= 0 && oi->contentp) { - *oi->contentp = unpack_loose_rest(&stream, hdr, - *oi->sizep, oid); - if (!*oi->contentp) { - git_inflate_end(&stream); - status = -1; - } - } else - git_inflate_end(&stream); - - munmap(map, mapsize); - if (status && oi->typep) - *oi->typep = status; - if (oi->sizep == &size_scratch) - oi->sizep = NULL; - strbuf_release(&hdrbuf); - oi->whence = OI_LOOSE; - return (status < 0) ? status : 0; -} - -int obj_read_use_lock = 0; -pthread_mutex_t obj_read_mutex; - -void enable_obj_read_lock(void) -{ - if (obj_read_use_lock) - return; - - obj_read_use_lock = 1; - init_recursive_mutex(&obj_read_mutex); -} - -void disable_obj_read_lock(void) -{ - if (!obj_read_use_lock) - return; - - obj_read_use_lock = 0; - pthread_mutex_destroy(&obj_read_mutex); -} - -int fetch_if_missing = 1; - -static int do_oid_object_info_extended(struct repository *r, - const struct object_id *oid, - struct object_info *oi, unsigned flags) -{ - static struct object_info blank_oi = OBJECT_INFO_INIT; - struct cached_object *co; - struct pack_entry e; - int rtype; - const struct object_id *real = oid; - int already_retried = 0; - - - if (flags & OBJECT_INFO_LOOKUP_REPLACE) - real = lookup_replace_object(r, oid); - - if (is_null_oid(real)) - return -1; - - if (!oi) - oi = &blank_oi; - - co = find_cached_object(real); - if (co) { - if (oi->typep) - *(oi->typep) = co->type; - if (oi->sizep) - *(oi->sizep) = co->size; - if (oi->disk_sizep) - *(oi->disk_sizep) = 0; - if (oi->delta_base_oid) - oidclr(oi->delta_base_oid); - if (oi->type_name) - strbuf_addstr(oi->type_name, type_name(co->type)); - if (oi->contentp) - *oi->contentp = xmemdupz(co->buf, co->size); - oi->whence = OI_CACHED; - return 0; - } - - while (1) { - if (find_pack_entry(r, real, &e)) - break; - - if (flags & OBJECT_INFO_IGNORE_LOOSE) - return -1; - - /* Most likely it's a loose object. */ - if (!loose_object_info(r, real, oi, flags)) - return 0; - - /* Not a loose object; someone else may have just packed it. */ - if (!(flags & OBJECT_INFO_QUICK)) { - reprepare_packed_git(r); - if (find_pack_entry(r, real, &e)) - break; - } - - /* Check if it is a missing object */ - if (fetch_if_missing && has_promisor_remote() && - !already_retried && r == the_repository && - !(flags & OBJECT_INFO_SKIP_FETCH_OBJECT)) { - /* - * TODO Investigate checking promisor_remote_get_direct() - * TODO return value and stopping on error here. - * TODO Pass a repository struct through - * promisor_remote_get_direct(), such that arbitrary - * repositories work. - */ - promisor_remote_get_direct(r, real, 1); - already_retried = 1; - continue; - } - - return -1; - } - - if (oi == &blank_oi) - /* - * We know that the caller doesn't actually need the - * information below, so return early. - */ - return 0; - rtype = packed_object_info(r, e.p, e.offset, oi); - if (rtype < 0) { - mark_bad_packed_object(e.p, real->hash); - return do_oid_object_info_extended(r, real, oi, 0); - } else if (oi->whence == OI_PACKED) { - oi->u.packed.offset = e.offset; - oi->u.packed.pack = e.p; - oi->u.packed.is_delta = (rtype == OBJ_REF_DELTA || - rtype == OBJ_OFS_DELTA); - } - - return 0; -} - -int oid_object_info_extended(struct repository *r, const struct object_id *oid, - struct object_info *oi, unsigned flags) -{ - int ret; - obj_read_lock(); - ret = do_oid_object_info_extended(r, oid, oi, flags); - obj_read_unlock(); - return ret; -} - - -/* returns enum object_type or negative */ -int oid_object_info(struct repository *r, - const struct object_id *oid, - unsigned long *sizep) -{ - enum object_type type; - struct object_info oi = OBJECT_INFO_INIT; - - oi.typep = &type; - oi.sizep = sizep; - if (oid_object_info_extended(r, oid, &oi, - OBJECT_INFO_LOOKUP_REPLACE) < 0) - return -1; - return type; -} - -static void *read_object(struct repository *r, - const struct object_id *oid, enum object_type *type, - unsigned long *size) -{ - struct object_info oi = OBJECT_INFO_INIT; - void *content; - oi.typep = type; - oi.sizep = size; - oi.contentp = &content; - - if (oid_object_info_extended(r, oid, &oi, 0) < 0) - return NULL; - return content; -} - -int pretend_object_file(void *buf, unsigned long len, enum object_type type, - struct object_id *oid) -{ - struct cached_object *co; - - hash_object_file(the_hash_algo, buf, len, type_name(type), oid); - if (has_object_file_with_flags(oid, OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT) || - find_cached_object(oid)) - return 0; - ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc); - co = &cached_objects[cached_object_nr++]; - co->size = len; - co->type = type; - co->buf = xmalloc(len); - memcpy(co->buf, buf, len); - oidcpy(&co->oid, oid); - return 0; -} - -/* - * This function dies on corrupt objects; the callers who want to - * deal with them should arrange to call read_object() and give error - * messages themselves. - */ -void *read_object_file_extended(struct repository *r, - const struct object_id *oid, - enum object_type *type, - unsigned long *size, - int lookup_replace) -{ - void *data; - const struct packed_git *p; - const char *path; - struct stat st; - const struct object_id *repl = lookup_replace ? - lookup_replace_object(r, oid) : oid; - - errno = 0; - data = read_object(r, repl, type, size); - if (data) - return data; - - obj_read_lock(); - if (errno && errno != ENOENT) - die_errno(_("failed to read object %s"), oid_to_hex(oid)); - - /* die if we replaced an object with one that does not exist */ - if (repl != oid) - die(_("replacement %s not found for %s"), - oid_to_hex(repl), oid_to_hex(oid)); - - if (!stat_loose_object(r, repl, &st, &path)) - die(_("loose object %s (stored in %s) is corrupt"), - oid_to_hex(repl), path); - - if ((p = has_packed_and_bad(r, repl->hash)) != NULL) - die(_("packed object %s (stored in %s) is corrupt"), - oid_to_hex(repl), p->pack_name); - obj_read_unlock(); - - return NULL; -} - -void *read_object_with_reference(struct repository *r, - const struct object_id *oid, - const char *required_type_name, - unsigned long *size, - struct object_id *actual_oid_return) -{ - enum object_type type, required_type; - void *buffer; - unsigned long isize; - struct object_id actual_oid; - - required_type = type_from_string(required_type_name); - oidcpy(&actual_oid, oid); - while (1) { - int ref_length = -1; - const char *ref_type = NULL; - - buffer = repo_read_object_file(r, &actual_oid, &type, &isize); - if (!buffer) - return NULL; - if (type == required_type) { - *size = isize; - if (actual_oid_return) - oidcpy(actual_oid_return, &actual_oid); - return buffer; - } - /* Handle references */ - else if (type == OBJ_COMMIT) - ref_type = "tree "; - else if (type == OBJ_TAG) - ref_type = "object "; - else { - free(buffer); - return NULL; - } - ref_length = strlen(ref_type); - - if (ref_length + the_hash_algo->hexsz > isize || - memcmp(buffer, ref_type, ref_length) || - get_oid_hex((char *) buffer + ref_length, &actual_oid)) { - free(buffer); - return NULL; - } - free(buffer); - /* Now we have the ID of the referred-to object in - * actual_oid. Check again. */ - } -} - -static void write_object_file_prepare(const struct git_hash_algo *algo, - const void *buf, unsigned long len, - const char *type, struct object_id *oid, - char *hdr, int *hdrlen) -{ - git_hash_ctx c; - - /* Generate the header */ - *hdrlen = xsnprintf(hdr, *hdrlen, "%s %"PRIuMAX , type, (uintmax_t)len)+1; - - /* Sha1.. */ - algo->init_fn(&c); - algo->update_fn(&c, hdr, *hdrlen); - algo->update_fn(&c, buf, len); - algo->final_fn(oid->hash, &c); -} - -/* - * Move the just written object into its final resting place. - */ -int finalize_object_file(const char *tmpfile, const char *filename) -{ - int ret = 0; - - if (object_creation_mode == OBJECT_CREATION_USES_RENAMES) - goto try_rename; - else if (link(tmpfile, filename)) - ret = errno; - - /* - * Coda hack - coda doesn't like cross-directory links, - * so we fall back to a rename, which will mean that it - * won't be able to check collisions, but that's not a - * big deal. - * - * The same holds for FAT formatted media. - * - * When this succeeds, we just return. We have nothing - * left to unlink. - */ - if (ret && ret != EEXIST) { - try_rename: - if (!rename(tmpfile, filename)) - goto out; - ret = errno; - } - unlink_or_warn(tmpfile); - if (ret) { - if (ret != EEXIST) { - return error_errno(_("unable to write file %s"), filename); - } - /* FIXME!!! Collision check here ? */ - } - -out: - if (adjust_shared_perm(filename)) - return error(_("unable to set permission to '%s'"), filename); - return 0; -} - -static int write_buffer(int fd, const void *buf, size_t len) -{ - if (write_in_full(fd, buf, len) < 0) - return error_errno(_("file write error")); - return 0; -} - -int hash_object_file(const struct git_hash_algo *algo, const void *buf, - unsigned long len, const char *type, - struct object_id *oid) -{ - char hdr[MAX_HEADER_LEN]; - int hdrlen = sizeof(hdr); - write_object_file_prepare(algo, buf, len, type, oid, hdr, &hdrlen); - return 0; -} - -/* Finalize a file on disk, and close it. */ -static void close_loose_object(int fd) -{ - if (fsync_object_files) - fsync_or_die(fd, "loose object file"); - if (close(fd) != 0) - die_errno(_("error when closing loose object file")); -} - -/* Size of directory component, including the ending '/' */ -static inline int directory_size(const char *filename) -{ - const char *s = strrchr(filename, '/'); - if (!s) - return 0; - return s - filename + 1; -} - -/* - * This creates a temporary file in the same directory as the final - * 'filename' - * - * We want to avoid cross-directory filename renames, because those - * can have problems on various filesystems (FAT, NFS, Coda). - */ -static int create_tmpfile(struct strbuf *tmp, const char *filename) -{ - int fd, dirlen = directory_size(filename); - - strbuf_reset(tmp); - strbuf_add(tmp, filename, dirlen); - strbuf_addstr(tmp, "tmp_obj_XXXXXX"); - fd = git_mkstemp_mode(tmp->buf, 0444); - if (fd < 0 && dirlen && errno == ENOENT) { - /* - * Make sure the directory exists; note that the contents - * of the buffer are undefined after mkstemp returns an - * error, so we have to rewrite the whole buffer from - * scratch. - */ - strbuf_reset(tmp); - strbuf_add(tmp, filename, dirlen - 1); - if (mkdir(tmp->buf, 0777) && errno != EEXIST) - return -1; - if (adjust_shared_perm(tmp->buf)) - return -1; - - /* Try again */ - strbuf_addstr(tmp, "/tmp_obj_XXXXXX"); - fd = git_mkstemp_mode(tmp->buf, 0444); - } - return fd; -} - -static int write_loose_object(const struct object_id *oid, char *hdr, - int hdrlen, const void *buf, unsigned long len, - time_t mtime) -{ - int fd, ret; - unsigned char compressed[4096]; - git_zstream stream; - git_hash_ctx c; - struct object_id parano_oid; - static struct strbuf tmp_file = STRBUF_INIT; - static struct strbuf filename = STRBUF_INIT; - - loose_object_path(the_repository, &filename, oid); - - fd = create_tmpfile(&tmp_file, filename.buf); - if (fd < 0) { - if (errno == EACCES) - return error(_("insufficient permission for adding an object to repository database %s"), get_object_directory()); - else - return error_errno(_("unable to create temporary file")); - } - - /* Set it up */ - git_deflate_init(&stream, zlib_compression_level); - stream.next_out = compressed; - stream.avail_out = sizeof(compressed); - the_hash_algo->init_fn(&c); - - /* First header.. */ - stream.next_in = (unsigned char *)hdr; - stream.avail_in = hdrlen; - while (git_deflate(&stream, 0) == Z_OK) - ; /* nothing */ - the_hash_algo->update_fn(&c, hdr, hdrlen); - - /* Then the data itself.. */ - stream.next_in = (void *)buf; - stream.avail_in = len; - do { - unsigned char *in0 = stream.next_in; - ret = git_deflate(&stream, Z_FINISH); - the_hash_algo->update_fn(&c, in0, stream.next_in - in0); - if (write_buffer(fd, compressed, stream.next_out - compressed) < 0) - die(_("unable to write loose object file")); - stream.next_out = compressed; - stream.avail_out = sizeof(compressed); - } while (ret == Z_OK); - - if (ret != Z_STREAM_END) - die(_("unable to deflate new object %s (%d)"), oid_to_hex(oid), - ret); - ret = git_deflate_end_gently(&stream); - if (ret != Z_OK) - die(_("deflateEnd on object %s failed (%d)"), oid_to_hex(oid), - ret); - the_hash_algo->final_fn(parano_oid.hash, &c); - if (!oideq(oid, ¶no_oid)) - die(_("confused by unstable object source data for %s"), - oid_to_hex(oid)); - - close_loose_object(fd); - - if (mtime) { - struct utimbuf utb; - utb.actime = mtime; - utb.modtime = mtime; - if (utime(tmp_file.buf, &utb) < 0) - warning_errno(_("failed utime() on %s"), tmp_file.buf); - } - - return finalize_object_file(tmp_file.buf, filename.buf); -} - -static int freshen_loose_object(const struct object_id *oid) -{ - return check_and_freshen(oid, 1); -} - -static int freshen_packed_object(const struct object_id *oid) -{ - struct pack_entry e; - if (!find_pack_entry(the_repository, oid, &e)) - return 0; - if (e.p->freshened) - return 1; - if (!freshen_file(e.p->pack_name)) - return 0; - e.p->freshened = 1; - return 1; -} - -int write_object_file(const void *buf, unsigned long len, const char *type, - struct object_id *oid) -{ - char hdr[MAX_HEADER_LEN]; - int hdrlen = sizeof(hdr); - - /* Normally if we have it in the pack then we do not bother writing - * it out into .git/objects/??/?{38} file. - */ - write_object_file_prepare(the_hash_algo, buf, len, type, oid, hdr, - &hdrlen); - if (freshen_packed_object(oid) || freshen_loose_object(oid)) - return 0; - return write_loose_object(oid, hdr, hdrlen, buf, len, 0); -} - -int hash_object_file_literally(const void *buf, unsigned long len, - const char *type, struct object_id *oid, - unsigned flags) -{ - char *header; - int hdrlen, status = 0; - - /* type string, SP, %lu of the length plus NUL must fit this */ - hdrlen = strlen(type) + MAX_HEADER_LEN; - header = xmalloc(hdrlen); - write_object_file_prepare(the_hash_algo, buf, len, type, oid, header, - &hdrlen); - - if (!(flags & HASH_WRITE_OBJECT)) - goto cleanup; - if (freshen_packed_object(oid) || freshen_loose_object(oid)) - goto cleanup; - status = write_loose_object(oid, header, hdrlen, buf, len, 0); - -cleanup: - free(header); - return status; -} - -int force_object_loose(const struct object_id *oid, time_t mtime) -{ - void *buf; - unsigned long len; - enum object_type type; - char hdr[MAX_HEADER_LEN]; - int hdrlen; - int ret; - - if (has_loose_object(oid)) - return 0; - buf = read_object(the_repository, oid, &type, &len); - if (!buf) - return error(_("cannot read object for %s"), oid_to_hex(oid)); - hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %"PRIuMAX , type_name(type), (uintmax_t)len) + 1; - ret = write_loose_object(oid, hdr, hdrlen, buf, len, mtime); - free(buf); - - return ret; -} - -int has_object(struct repository *r, const struct object_id *oid, - unsigned flags) -{ - int quick = !(flags & HAS_OBJECT_RECHECK_PACKED); - unsigned object_info_flags = OBJECT_INFO_SKIP_FETCH_OBJECT | - (quick ? OBJECT_INFO_QUICK : 0); - - if (!startup_info->have_repository) - return 0; - return oid_object_info_extended(r, oid, NULL, object_info_flags) >= 0; -} - -int repo_has_object_file_with_flags(struct repository *r, - const struct object_id *oid, int flags) -{ - if (!startup_info->have_repository) - return 0; - return oid_object_info_extended(r, oid, NULL, flags) >= 0; -} - -int repo_has_object_file(struct repository *r, - const struct object_id *oid) -{ - return repo_has_object_file_with_flags(r, oid, 0); -} - -static void check_tree(const void *buf, size_t size) -{ - struct tree_desc desc; - struct name_entry entry; - - init_tree_desc(&desc, buf, size); - while (tree_entry(&desc, &entry)) - /* do nothing - * tree_entry() will die() on malformed entries */ - ; -} - -static void check_commit(const void *buf, size_t size) -{ - struct commit c; - memset(&c, 0, sizeof(c)); - if (parse_commit_buffer(the_repository, &c, buf, size, 0)) - die(_("corrupt commit")); -} - -static void check_tag(const void *buf, size_t size) -{ - struct tag t; - memset(&t, 0, sizeof(t)); - if (parse_tag_buffer(the_repository, &t, buf, size)) - die(_("corrupt tag")); -} - -static int index_mem(struct index_state *istate, - struct object_id *oid, void *buf, size_t size, - enum object_type type, - const char *path, unsigned flags) -{ - int ret, re_allocated = 0; - int write_object = flags & HASH_WRITE_OBJECT; - - if (!type) - type = OBJ_BLOB; - - /* - * Convert blobs to git internal format - */ - if ((type == OBJ_BLOB) && path) { - struct strbuf nbuf = STRBUF_INIT; - if (convert_to_git(istate, path, buf, size, &nbuf, - get_conv_flags(flags))) { - buf = strbuf_detach(&nbuf, &size); - re_allocated = 1; - } - } - if (flags & HASH_FORMAT_CHECK) { - if (type == OBJ_TREE) - check_tree(buf, size); - if (type == OBJ_COMMIT) - check_commit(buf, size); - if (type == OBJ_TAG) - check_tag(buf, size); - } - - if (write_object) - ret = write_object_file(buf, size, type_name(type), oid); - else - ret = hash_object_file(the_hash_algo, buf, size, - type_name(type), oid); - if (re_allocated) - free(buf); - return ret; -} - -static int index_stream_convert_blob(struct index_state *istate, - struct object_id *oid, - int fd, - const char *path, - unsigned flags) -{ - int ret; - const int write_object = flags & HASH_WRITE_OBJECT; - struct strbuf sbuf = STRBUF_INIT; - - assert(path); - assert(would_convert_to_git_filter_fd(istate, path)); - - convert_to_git_filter_fd(istate, path, fd, &sbuf, - get_conv_flags(flags)); - - if (write_object) - ret = write_object_file(sbuf.buf, sbuf.len, type_name(OBJ_BLOB), - oid); - else - ret = hash_object_file(the_hash_algo, sbuf.buf, sbuf.len, - type_name(OBJ_BLOB), oid); - strbuf_release(&sbuf); - return ret; -} - -static int index_pipe(struct index_state *istate, struct object_id *oid, - int fd, enum object_type type, - const char *path, unsigned flags) -{ - struct strbuf sbuf = STRBUF_INIT; - int ret; - - if (strbuf_read(&sbuf, fd, 4096) >= 0) - ret = index_mem(istate, oid, sbuf.buf, sbuf.len, type, path, flags); - else - ret = -1; - strbuf_release(&sbuf); - return ret; -} - -#define SMALL_FILE_SIZE (32*1024) - -static int index_core(struct index_state *istate, - struct object_id *oid, int fd, size_t size, - enum object_type type, const char *path, - unsigned flags) -{ - int ret; - - if (!size) { - ret = index_mem(istate, oid, "", size, type, path, flags); - } else if (size <= SMALL_FILE_SIZE) { - char *buf = xmalloc(size); - ssize_t read_result = read_in_full(fd, buf, size); - if (read_result < 0) - ret = error_errno(_("read error while indexing %s"), - path ? path : ""); - else if (read_result != size) - ret = error(_("short read while indexing %s"), - path ? path : ""); - else - ret = index_mem(istate, oid, buf, size, type, path, flags); - free(buf); - } else { - void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); - ret = index_mem(istate, oid, buf, size, type, path, flags); - munmap(buf, size); - } - return ret; -} - -/* - * This creates one packfile per large blob unless bulk-checkin - * machinery is "plugged". - * - * This also bypasses the usual "convert-to-git" dance, and that is on - * purpose. We could write a streaming version of the converting - * functions and insert that before feeding the data to fast-import - * (or equivalent in-core API described above). However, that is - * somewhat complicated, as we do not know the size of the filter - * result, which we need to know beforehand when writing a git object. - * Since the primary motivation for trying to stream from the working - * tree file and to avoid mmaping it in core is to deal with large - * binary blobs, they generally do not want to get any conversion, and - * callers should avoid this code path when filters are requested. - */ -static int index_stream(struct object_id *oid, int fd, size_t size, - enum object_type type, const char *path, - unsigned flags) -{ - return index_bulk_checkin(oid, fd, size, type, path, flags); -} - -int index_fd(struct index_state *istate, struct object_id *oid, - int fd, struct stat *st, - enum object_type type, const char *path, unsigned flags) -{ - int ret; - - /* - * Call xsize_t() only when needed to avoid potentially unnecessary - * die() for large files. - */ - if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(istate, path)) - ret = index_stream_convert_blob(istate, oid, fd, path, flags); - else if (!S_ISREG(st->st_mode)) - ret = index_pipe(istate, oid, fd, type, path, flags); - else if (st->st_size <= big_file_threshold || type != OBJ_BLOB || - (path && would_convert_to_git(istate, path))) - ret = index_core(istate, oid, fd, xsize_t(st->st_size), - type, path, flags); - else - ret = index_stream(oid, fd, xsize_t(st->st_size), type, path, - flags); - close(fd); - return ret; -} - -int index_path(struct index_state *istate, struct object_id *oid, - const char *path, struct stat *st, unsigned flags) -{ - int fd; - struct strbuf sb = STRBUF_INIT; - int rc = 0; - - switch (st->st_mode & S_IFMT) { - case S_IFREG: - fd = open(path, O_RDONLY); - if (fd < 0) - return error_errno("open(\"%s\")", path); - if (index_fd(istate, oid, fd, st, OBJ_BLOB, path, flags) < 0) - return error(_("%s: failed to insert into database"), - path); - break; - case S_IFLNK: - if (strbuf_readlink(&sb, path, st->st_size)) - return error_errno("readlink(\"%s\")", path); - if (!(flags & HASH_WRITE_OBJECT)) - hash_object_file(the_hash_algo, sb.buf, sb.len, - blob_type, oid); - else if (write_object_file(sb.buf, sb.len, blob_type, oid)) - rc = error(_("%s: failed to insert into database"), path); - strbuf_release(&sb); - break; - case S_IFDIR: - return resolve_gitlink_ref(path, "HEAD", oid); - default: - return error(_("%s: unsupported file type"), path); - } - return rc; -} - -int read_pack_header(int fd, struct pack_header *header) -{ - if (read_in_full(fd, header, sizeof(*header)) != sizeof(*header)) - /* "eof before pack header was fully read" */ - return PH_ERROR_EOF; - - if (header->hdr_signature != htonl(PACK_SIGNATURE)) - /* "protocol error (pack signature mismatch detected)" */ - return PH_ERROR_PACK_SIGNATURE; - if (!pack_version_ok(header->hdr_version)) - /* "protocol error (pack version unsupported)" */ - return PH_ERROR_PROTOCOL; - return 0; -} - -void assert_oid_type(const struct object_id *oid, enum object_type expect) -{ - enum object_type type = oid_object_info(the_repository, oid, NULL); - if (type < 0) - die(_("%s is not a valid object"), oid_to_hex(oid)); - if (type != expect) - die(_("%s is not a valid '%s' object"), oid_to_hex(oid), - type_name(expect)); -} - -int for_each_file_in_obj_subdir(unsigned int subdir_nr, - struct strbuf *path, - each_loose_object_fn obj_cb, - each_loose_cruft_fn cruft_cb, - each_loose_subdir_fn subdir_cb, - void *data) -{ - size_t origlen, baselen; - DIR *dir; - struct dirent *de; - int r = 0; - struct object_id oid; - - if (subdir_nr > 0xff) - BUG("invalid loose object subdirectory: %x", subdir_nr); - - origlen = path->len; - strbuf_complete(path, '/'); - strbuf_addf(path, "%02x", subdir_nr); - - dir = opendir(path->buf); - if (!dir) { - if (errno != ENOENT) - r = error_errno(_("unable to open %s"), path->buf); - strbuf_setlen(path, origlen); - return r; - } - - oid.hash[0] = subdir_nr; - strbuf_addch(path, '/'); - baselen = path->len; - - while ((de = readdir(dir))) { - size_t namelen; - if (is_dot_or_dotdot(de->d_name)) - continue; - - namelen = strlen(de->d_name); - strbuf_setlen(path, baselen); - strbuf_add(path, de->d_name, namelen); - if (namelen == the_hash_algo->hexsz - 2 && - !hex_to_bytes(oid.hash + 1, de->d_name, - the_hash_algo->rawsz - 1)) { - if (obj_cb) { - r = obj_cb(&oid, path->buf, data); - if (r) - break; - } - continue; - } - - if (cruft_cb) { - r = cruft_cb(de->d_name, path->buf, data); - if (r) - break; - } - } - closedir(dir); - - strbuf_setlen(path, baselen - 1); - if (!r && subdir_cb) - r = subdir_cb(subdir_nr, path->buf, data); - - strbuf_setlen(path, origlen); - - return r; -} - -int for_each_loose_file_in_objdir_buf(struct strbuf *path, - each_loose_object_fn obj_cb, - each_loose_cruft_fn cruft_cb, - each_loose_subdir_fn subdir_cb, - void *data) -{ - int r = 0; - int i; - - for (i = 0; i < 256; i++) { - r = for_each_file_in_obj_subdir(i, path, obj_cb, cruft_cb, - subdir_cb, data); - if (r) - break; - } - - return r; -} - -int for_each_loose_file_in_objdir(const char *path, - each_loose_object_fn obj_cb, - each_loose_cruft_fn cruft_cb, - each_loose_subdir_fn subdir_cb, - void *data) -{ - struct strbuf buf = STRBUF_INIT; - int r; - - strbuf_addstr(&buf, path); - r = for_each_loose_file_in_objdir_buf(&buf, obj_cb, cruft_cb, - subdir_cb, data); - strbuf_release(&buf); - - return r; -} - -int for_each_loose_object(each_loose_object_fn cb, void *data, - enum for_each_object_flags flags) -{ - struct object_directory *odb; - - prepare_alt_odb(the_repository); - for (odb = the_repository->objects->odb; odb; odb = odb->next) { - int r = for_each_loose_file_in_objdir(odb->path, cb, NULL, - NULL, data); - if (r) - return r; - - if (flags & FOR_EACH_OBJECT_LOCAL_ONLY) - break; - } - - return 0; -} - -static int append_loose_object(const struct object_id *oid, const char *path, - void *data) -{ - oid_array_append(data, oid); - return 0; -} - -struct oid_array *odb_loose_cache(struct object_directory *odb, - const struct object_id *oid) -{ - int subdir_nr = oid->hash[0]; - struct strbuf buf = STRBUF_INIT; - - if (subdir_nr < 0 || - subdir_nr >= ARRAY_SIZE(odb->loose_objects_subdir_seen)) - BUG("subdir_nr out of range"); - - if (odb->loose_objects_subdir_seen[subdir_nr]) - return &odb->loose_objects_cache[subdir_nr]; - - strbuf_addstr(&buf, odb->path); - for_each_file_in_obj_subdir(subdir_nr, &buf, - append_loose_object, - NULL, NULL, - &odb->loose_objects_cache[subdir_nr]); - odb->loose_objects_subdir_seen[subdir_nr] = 1; - strbuf_release(&buf); - return &odb->loose_objects_cache[subdir_nr]; -} - -void odb_clear_loose_cache(struct object_directory *odb) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(odb->loose_objects_cache); i++) - oid_array_clear(&odb->loose_objects_cache[i]); - memset(&odb->loose_objects_subdir_seen, 0, - sizeof(odb->loose_objects_subdir_seen)); -} - -static int check_stream_oid(git_zstream *stream, - const char *hdr, - unsigned long size, - const char *path, - const struct object_id *expected_oid) -{ - git_hash_ctx c; - struct object_id real_oid; - unsigned char buf[4096]; - unsigned long total_read; - int status = Z_OK; - - the_hash_algo->init_fn(&c); - the_hash_algo->update_fn(&c, hdr, stream->total_out); - - /* - * We already read some bytes into hdr, but the ones up to the NUL - * do not count against the object's content size. - */ - total_read = stream->total_out - strlen(hdr) - 1; - - /* - * This size comparison must be "<=" to read the final zlib packets; - * see the comment in unpack_loose_rest for details. - */ - while (total_read <= size && - (status == Z_OK || - (status == Z_BUF_ERROR && !stream->avail_out))) { - stream->next_out = buf; - stream->avail_out = sizeof(buf); - if (size - total_read < stream->avail_out) - stream->avail_out = size - total_read; - status = git_inflate(stream, Z_FINISH); - the_hash_algo->update_fn(&c, buf, stream->next_out - buf); - total_read += stream->next_out - buf; - } - git_inflate_end(stream); - - if (status != Z_STREAM_END) { - error(_("corrupt loose object '%s'"), oid_to_hex(expected_oid)); - return -1; - } - if (stream->avail_in) { - error(_("garbage at end of loose object '%s'"), - oid_to_hex(expected_oid)); - return -1; - } - - the_hash_algo->final_fn(real_oid.hash, &c); - if (!oideq(expected_oid, &real_oid)) { - error(_("hash mismatch for %s (expected %s)"), path, - oid_to_hex(expected_oid)); - return -1; - } - - return 0; -} - -int read_loose_object(const char *path, - const struct object_id *expected_oid, - enum object_type *type, - unsigned long *size, - void **contents) -{ - int ret = -1; - void *map = NULL; - unsigned long mapsize; - git_zstream stream; - char hdr[MAX_HEADER_LEN]; - - *contents = NULL; - - map = map_loose_object_1(the_repository, path, NULL, &mapsize); - if (!map) { - error_errno(_("unable to mmap %s"), path); - goto out; - } - - if (unpack_loose_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0) { - error(_("unable to unpack header of %s"), path); - goto out; - } - - *type = parse_loose_header(hdr, size); - if (*type < 0) { - error(_("unable to parse header of %s"), path); - git_inflate_end(&stream); - goto out; - } - - if (*type == OBJ_BLOB && *size > big_file_threshold) { - if (check_stream_oid(&stream, hdr, *size, path, expected_oid) < 0) - goto out; - } else { - *contents = unpack_loose_rest(&stream, hdr, *size, expected_oid); - if (!*contents) { - error(_("unable to unpack contents of %s"), path); - git_inflate_end(&stream); - goto out; - } - if (check_object_signature(the_repository, expected_oid, - *contents, *size, - type_name(*type))) { - error(_("hash mismatch for %s (expected %s)"), path, - oid_to_hex(expected_oid)); - free(*contents); - goto out; - } - } - - ret = 0; /* everything checks out */ - -out: - if (map) - munmap(map, mapsize); - return ret; -} diff --git a/t/oid-info/README b/t/oid-info/README index 27f843fc00..ca56a74b1e 100644 --- a/t/oid-info/README +++ b/t/oid-info/README @@ -5,7 +5,7 @@ starting with `#` are ignored. The key and value are separated by whitespace (specifically, those whitespace in the default `$IFS`). The key consists only of shell identifier characters, and the value consists of a hash algorithm, colon, and value. The hash algorithm also consists only of shell identifier -characters; it should match the value in sha1-file.c. +characters; it should match the value in object-file.c. For example, the following lines map the key "rawsz" to "20" if SHA-1 is in use and to "32" if SHA-256 is in use: -- cgit v1.3-5-g9baa From 7a7d992d0dbd78cf1fc477cf1e1caf61833b3e41 Mon Sep 17 00:00:00 2001 From: Martin Ågren Date: Thu, 31 Dec 2020 12:56:22 +0100 Subject: sha1-lookup: rename `sha1_pos()` as `hash_pos()` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Rename this function to reflect that we're not just able to handle SHA-1 these days. There are a few instances of "sha1" left in sha1-lookup.[ch] after this, but those will be addressed in the next commit. Signed-off-by: Martin Ågren Reviewed-by: Derrick Stolee Signed-off-by: Junio C Hamano --- builtin/name-rev.c | 2 +- commit-graph.c | 6 +++--- commit.c | 2 +- oid-array.c | 2 +- pack-bitmap-write.c | 2 +- rerere.c | 2 +- sha1-lookup.c | 8 ++++---- sha1-lookup.h | 6 +++--- 8 files changed, 15 insertions(+), 15 deletions(-) diff --git a/builtin/name-rev.c b/builtin/name-rev.c index 725dd04519..4939ceb2e5 100644 --- a/builtin/name-rev.c +++ b/builtin/name-rev.c @@ -408,7 +408,7 @@ static const char *get_exact_ref_match(const struct object *o) tip_table.sorted = 1; } - found = sha1_pos(o->oid.hash, tip_table.table, tip_table.nr, + found = hash_pos(o->oid.hash, tip_table.table, tip_table.nr, nth_tip_table_ent); if (0 <= found) return tip_table.table[found].refname; diff --git a/commit-graph.c b/commit-graph.c index 06f8dc1d89..c672feee91 100644 --- a/commit-graph.c +++ b/commit-graph.c @@ -1043,7 +1043,7 @@ static int write_graph_chunk_data(struct hashfile *f, if (!parent) edge_value = GRAPH_PARENT_NONE; else { - edge_value = sha1_pos(parent->item->object.oid.hash, + edge_value = hash_pos(parent->item->object.oid.hash, ctx->commits.list, ctx->commits.nr, commit_to_sha1); @@ -1074,7 +1074,7 @@ static int write_graph_chunk_data(struct hashfile *f, else if (parent->next) edge_value = GRAPH_EXTRA_EDGES_NEEDED | num_extra_edges; else { - edge_value = sha1_pos(parent->item->object.oid.hash, + edge_value = hash_pos(parent->item->object.oid.hash, ctx->commits.list, ctx->commits.nr, commit_to_sha1); @@ -1143,7 +1143,7 @@ static int write_graph_chunk_extra_edges(struct hashfile *f, /* Since num_parents > 2, this initializer is safe. */ for (parent = (*list)->parents->next; parent; parent = parent->next) { - int edge_value = sha1_pos(parent->item->object.oid.hash, + int edge_value = hash_pos(parent->item->object.oid.hash, ctx->commits.list, ctx->commits.nr, commit_to_sha1); diff --git a/commit.c b/commit.c index fe1fa3dc41..0b7bace022 100644 --- a/commit.c +++ b/commit.c @@ -113,7 +113,7 @@ static const unsigned char *commit_graft_sha1_access(size_t index, void *table) int commit_graft_pos(struct repository *r, const unsigned char *sha1) { - return sha1_pos(sha1, r->parsed_objects->grafts, + return hash_pos(sha1, r->parsed_objects->grafts, r->parsed_objects->grafts_nr, commit_graft_sha1_access); } diff --git a/oid-array.c b/oid-array.c index 8e1bcedc0c..fb4c3dd795 100644 --- a/oid-array.c +++ b/oid-array.c @@ -31,7 +31,7 @@ static const unsigned char *sha1_access(size_t index, void *table) int oid_array_lookup(struct oid_array *array, const struct object_id *oid) { oid_array_sort(array); - return sha1_pos(oid->hash, array->oid, array->nr, sha1_access); + return hash_pos(oid->hash, array->oid, array->nr, sha1_access); } void oid_array_clear(struct oid_array *array) diff --git a/pack-bitmap-write.c b/pack-bitmap-write.c index 5e998bdaa7..27ece05ec7 100644 --- a/pack-bitmap-write.c +++ b/pack-bitmap-write.c @@ -482,7 +482,7 @@ static void write_selected_commits_v1(struct hashfile *f, struct bitmapped_commit *stored = &writer.selected[i]; int commit_pos = - sha1_pos(stored->commit->object.oid.hash, index, index_nr, sha1_access); + hash_pos(stored->commit->object.oid.hash, index, index_nr, sha1_access); if (commit_pos < 0) BUG("trying to write commit not in index"); diff --git a/rerere.c b/rerere.c index 9281131a9f..9fc76eb756 100644 --- a/rerere.c +++ b/rerere.c @@ -147,7 +147,7 @@ static struct rerere_dir *find_rerere_dir(const char *hex) if (get_sha1_hex(hex, hash)) return NULL; /* BUG */ - pos = sha1_pos(hash, rerere_dir, rerere_dir_nr, rerere_dir_hash); + pos = hash_pos(hash, rerere_dir, rerere_dir_nr, rerere_dir_hash); if (pos < 0) { rr_dir = xmalloc(sizeof(*rr_dir)); hashcpy(rr_dir->hash, hash); diff --git a/sha1-lookup.c b/sha1-lookup.c index 29185844ec..45489edfe8 100644 --- a/sha1-lookup.c +++ b/sha1-lookup.c @@ -47,11 +47,11 @@ static uint32_t take2(const unsigned char *sha1) */ /* * The table should contain "nr" elements. - * The sha1 of element i (between 0 and nr - 1) should be returned + * The hash of element i (between 0 and nr - 1) should be returned * by "fn(i, table)". */ -int sha1_pos(const unsigned char *hash, void *table, size_t nr, - sha1_access_fn fn) +int hash_pos(const unsigned char *hash, void *table, size_t nr, + hash_access_fn fn) { size_t hi = nr; size_t lo = 0; @@ -74,7 +74,7 @@ int sha1_pos(const unsigned char *hash, void *table, size_t nr, if (lov != hiv) { /* * At this point miv could be equal - * to hiv (but sha1 could still be higher); + * to hiv (but hash could still be higher); * the invariant of (mi < hi) should be * kept. */ diff --git a/sha1-lookup.h b/sha1-lookup.h index 5afcd011c6..79973d4785 100644 --- a/sha1-lookup.h +++ b/sha1-lookup.h @@ -1,12 +1,12 @@ #ifndef SHA1_LOOKUP_H #define SHA1_LOOKUP_H -typedef const unsigned char *sha1_access_fn(size_t index, void *table); +typedef const unsigned char *hash_access_fn(size_t index, void *table); -int sha1_pos(const unsigned char *sha1, +int hash_pos(const unsigned char *hash, void *table, size_t nr, - sha1_access_fn fn); + hash_access_fn fn); /* * Searches for sha1 in table, using the given fanout table to determine the -- cgit v1.3-5-g9baa From bc626927575cea80b8bc5fd0dbb6c6439e34e606 Mon Sep 17 00:00:00 2001 From: Martin Ågren Date: Thu, 31 Dec 2020 12:56:23 +0100 Subject: hash-lookup: rename from sha1-lookup MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change all remnants of "sha1" in hash-lookup.c and .h and rename them to reflect that we're not just able to handle SHA-1 these days. Signed-off-by: Martin Ågren Reviewed-by: Derrick Stolee Signed-off-by: Junio C Hamano --- Makefile | 2 +- bisect.c | 2 +- builtin/name-rev.c | 2 +- commit-graph.c | 2 +- commit.c | 2 +- hash-lookup.c | 129 ++++++++++++++++++++++++++++++++++++++++++++++++++++ hash-lookup.h | 32 +++++++++++++ midx.c | 2 +- object-file.c | 2 +- oid-array.c | 2 +- pack-bitmap-write.c | 2 +- packfile.c | 2 +- patch-ids.c | 2 +- rerere.c | 2 +- sha1-lookup.c | 129 ---------------------------------------------------- sha1-lookup.h | 32 ------------- 16 files changed, 173 insertions(+), 173 deletions(-) create mode 100644 hash-lookup.c create mode 100644 hash-lookup.h delete mode 100644 sha1-lookup.c delete mode 100644 sha1-lookup.h diff --git a/Makefile b/Makefile index 224a1c6940..7a141facc7 100644 --- a/Makefile +++ b/Makefile @@ -901,6 +901,7 @@ LIB_OBJS += gettext.o LIB_OBJS += gpg-interface.o LIB_OBJS += graph.o LIB_OBJS += grep.o +LIB_OBJS += hash-lookup.o LIB_OBJS += hashmap.o LIB_OBJS += help.o LIB_OBJS += hex.o @@ -995,7 +996,6 @@ LIB_OBJS += sequencer.o LIB_OBJS += serve.o LIB_OBJS += server-info.o LIB_OBJS += setup.o -LIB_OBJS += sha1-lookup.o LIB_OBJS += shallow.o LIB_OBJS += sideband.o LIB_OBJS += sigchain.o diff --git a/bisect.c b/bisect.c index d8c2c8f7a7..75ea0eb57f 100644 --- a/bisect.c +++ b/bisect.c @@ -6,7 +6,7 @@ #include "refs.h" #include "list-objects.h" #include "quote.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" #include "run-command.h" #include "log-tree.h" #include "bisect.h" diff --git a/builtin/name-rev.c b/builtin/name-rev.c index 4939ceb2e5..3fe71a8c01 100644 --- a/builtin/name-rev.c +++ b/builtin/name-rev.c @@ -7,7 +7,7 @@ #include "refs.h" #include "parse-options.h" #include "prio-queue.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" #include "commit-slab.h" /* diff --git a/commit-graph.c b/commit-graph.c index c672feee91..e9124d4a41 100644 --- a/commit-graph.c +++ b/commit-graph.c @@ -7,7 +7,7 @@ #include "object.h" #include "refs.h" #include "revision.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" #include "commit-graph.h" #include "object-store.h" #include "alloc.h" diff --git a/commit.c b/commit.c index 0b7bace022..cb119ebdf2 100644 --- a/commit.c +++ b/commit.c @@ -14,7 +14,7 @@ #include "mergesort.h" #include "commit-slab.h" #include "prio-queue.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" #include "wt-status.h" #include "advice.h" #include "refs.h" diff --git a/hash-lookup.c b/hash-lookup.c new file mode 100644 index 0000000000..1191856a32 --- /dev/null +++ b/hash-lookup.c @@ -0,0 +1,129 @@ +#include "cache.h" +#include "hash-lookup.h" + +static uint32_t take2(const unsigned char *hash) +{ + return ((hash[0] << 8) | hash[1]); +} + +/* + * Conventional binary search loop looks like this: + * + * do { + * int mi = lo + (hi - lo) / 2; + * int cmp = "entry pointed at by mi" minus "target"; + * if (!cmp) + * return (mi is the wanted one) + * if (cmp > 0) + * hi = mi; "mi is larger than target" + * else + * lo = mi+1; "mi is smaller than target" + * } while (lo < hi); + * + * The invariants are: + * + * - When entering the loop, lo points at a slot that is never + * above the target (it could be at the target), hi points at a + * slot that is guaranteed to be above the target (it can never + * be at the target). + * + * - We find a point 'mi' between lo and hi (mi could be the same + * as lo, but never can be the same as hi), and check if it hits + * the target. There are three cases: + * + * - if it is a hit, we are happy. + * + * - if it is strictly higher than the target, we update hi with + * it. + * + * - if it is strictly lower than the target, we update lo to be + * one slot after it, because we allow lo to be at the target. + * + * When choosing 'mi', we do not have to take the "middle" but + * anywhere in between lo and hi, as long as lo <= mi < hi is + * satisfied. When we somehow know that the distance between the + * target and lo is much shorter than the target and hi, we could + * pick mi that is much closer to lo than the midway. + */ +/* + * The table should contain "nr" elements. + * The hash of element i (between 0 and nr - 1) should be returned + * by "fn(i, table)". + */ +int hash_pos(const unsigned char *hash, void *table, size_t nr, + hash_access_fn fn) +{ + size_t hi = nr; + size_t lo = 0; + size_t mi = 0; + + if (!nr) + return -1; + + if (nr != 1) { + size_t lov, hiv, miv, ofs; + + for (ofs = 0; ofs < the_hash_algo->rawsz - 2; ofs += 2) { + lov = take2(fn(0, table) + ofs); + hiv = take2(fn(nr - 1, table) + ofs); + miv = take2(hash + ofs); + if (miv < lov) + return -1; + if (hiv < miv) + return index_pos_to_insert_pos(nr); + if (lov != hiv) { + /* + * At this point miv could be equal + * to hiv (but hash could still be higher); + * the invariant of (mi < hi) should be + * kept. + */ + mi = (nr - 1) * (miv - lov) / (hiv - lov); + if (lo <= mi && mi < hi) + break; + BUG("assertion failed in binary search"); + } + } + } + + do { + int cmp; + cmp = hashcmp(fn(mi, table), hash); + if (!cmp) + return mi; + if (cmp > 0) + hi = mi; + else + lo = mi + 1; + mi = lo + (hi - lo) / 2; + } while (lo < hi); + return index_pos_to_insert_pos(lo); +} + +int bsearch_hash(const unsigned char *hash, const uint32_t *fanout_nbo, + const unsigned char *table, size_t stride, uint32_t *result) +{ + uint32_t hi, lo; + + hi = ntohl(fanout_nbo[*hash]); + lo = ((*hash == 0x0) ? 0 : ntohl(fanout_nbo[*hash - 1])); + + while (lo < hi) { + unsigned mi = lo + (hi - lo) / 2; + int cmp = hashcmp(table + mi * stride, hash); + + if (!cmp) { + if (result) + *result = mi; + return 1; + } + if (cmp > 0) + hi = mi; + else + lo = mi + 1; + } + + if (result) + *result = lo; + return 0; +} diff --git a/hash-lookup.h b/hash-lookup.h new file mode 100644 index 0000000000..5d476dec72 --- /dev/null +++ b/hash-lookup.h @@ -0,0 +1,32 @@ +#ifndef HASH_LOOKUP_H +#define HASH_LOOKUP_H + +typedef const unsigned char *hash_access_fn(size_t index, void *table); + +int hash_pos(const unsigned char *hash, + void *table, + size_t nr, + hash_access_fn fn); + +/* + * Searches for hash in table, using the given fanout table to determine the + * interval to search, then using binary search. Returns 1 if found, 0 if not. + * + * Takes the following parameters: + * + * - hash: the hash to search for + * - fanout_nbo: a 256-element array of NETWORK-order 32-bit integers; the + * integer at position i represents the number of elements in table whose + * first byte is less than or equal to i + * - table: a sorted list of hashes with optional extra information in between + * - stride: distance between two consecutive elements in table (should be + * GIT_MAX_RAWSZ or greater) + * - result: if not NULL, this function stores the element index of the + * position found (if the search is successful) or the index of the least + * element that is greater than hash (if the search is not successful) + * + * This function does not verify the validity of the fanout table. + */ +int bsearch_hash(const unsigned char *hash, const uint32_t *fanout_nbo, + const unsigned char *table, size_t stride, uint32_t *result); +#endif diff --git a/midx.c b/midx.c index 79c282b070..f9d9b832bb 100644 --- a/midx.c +++ b/midx.c @@ -5,7 +5,7 @@ #include "lockfile.h" #include "packfile.h" #include "object-store.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" #include "midx.h" #include "progress.h" #include "trace2.h" diff --git a/object-file.c b/object-file.c index 3508598d97..5bcfde8471 100644 --- a/object-file.c +++ b/object-file.c @@ -20,7 +20,7 @@ #include "tree-walk.h" #include "refs.h" #include "pack-revindex.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" #include "bulk-checkin.h" #include "repository.h" #include "replace-object.h" diff --git a/oid-array.c b/oid-array.c index fb4c3dd795..889b311f22 100644 --- a/oid-array.c +++ b/oid-array.c @@ -1,6 +1,6 @@ #include "cache.h" #include "oid-array.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" void oid_array_append(struct oid_array *array, const struct object_id *oid) { diff --git a/pack-bitmap-write.c b/pack-bitmap-write.c index 27ece05ec7..ae6d1475f9 100644 --- a/pack-bitmap-write.c +++ b/pack-bitmap-write.c @@ -9,7 +9,7 @@ #include "pack-revindex.h" #include "pack.h" #include "pack-bitmap.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" #include "pack-objects.h" #include "commit-reach.h" diff --git a/packfile.c b/packfile.c index 86f5c8dbf6..62d92e0c7c 100644 --- a/packfile.c +++ b/packfile.c @@ -7,7 +7,7 @@ #include "packfile.h" #include "delta.h" #include "streaming.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" #include "commit.h" #include "object.h" #include "tag.h" diff --git a/patch-ids.c b/patch-ids.c index 21973e4933..cf5e8045b7 100644 --- a/patch-ids.c +++ b/patch-ids.c @@ -1,7 +1,7 @@ #include "cache.h" #include "diff.h" #include "commit.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" #include "patch-ids.h" static int patch_id_defined(struct commit *commit) diff --git a/rerere.c b/rerere.c index 9fc76eb756..d6928c1b5c 100644 --- a/rerere.c +++ b/rerere.c @@ -10,7 +10,7 @@ #include "attr.h" #include "pathspec.h" #include "object-store.h" -#include "sha1-lookup.h" +#include "hash-lookup.h" #define RESOLVED 0 #define PUNTED 1 diff --git a/sha1-lookup.c b/sha1-lookup.c deleted file mode 100644 index 45489edfe8..0000000000 --- a/sha1-lookup.c +++ /dev/null @@ -1,129 +0,0 @@ -#include "cache.h" -#include "sha1-lookup.h" - -static uint32_t take2(const unsigned char *sha1) -{ - return ((sha1[0] << 8) | sha1[1]); -} - -/* - * Conventional binary search loop looks like this: - * - * do { - * int mi = lo + (hi - lo) / 2; - * int cmp = "entry pointed at by mi" minus "target"; - * if (!cmp) - * return (mi is the wanted one) - * if (cmp > 0) - * hi = mi; "mi is larger than target" - * else - * lo = mi+1; "mi is smaller than target" - * } while (lo < hi); - * - * The invariants are: - * - * - When entering the loop, lo points at a slot that is never - * above the target (it could be at the target), hi points at a - * slot that is guaranteed to be above the target (it can never - * be at the target). - * - * - We find a point 'mi' between lo and hi (mi could be the same - * as lo, but never can be the same as hi), and check if it hits - * the target. There are three cases: - * - * - if it is a hit, we are happy. - * - * - if it is strictly higher than the target, we update hi with - * it. - * - * - if it is strictly lower than the target, we update lo to be - * one slot after it, because we allow lo to be at the target. - * - * When choosing 'mi', we do not have to take the "middle" but - * anywhere in between lo and hi, as long as lo <= mi < hi is - * satisfied. When we somehow know that the distance between the - * target and lo is much shorter than the target and hi, we could - * pick mi that is much closer to lo than the midway. - */ -/* - * The table should contain "nr" elements. - * The hash of element i (between 0 and nr - 1) should be returned - * by "fn(i, table)". - */ -int hash_pos(const unsigned char *hash, void *table, size_t nr, - hash_access_fn fn) -{ - size_t hi = nr; - size_t lo = 0; - size_t mi = 0; - - if (!nr) - return -1; - - if (nr != 1) { - size_t lov, hiv, miv, ofs; - - for (ofs = 0; ofs < the_hash_algo->rawsz - 2; ofs += 2) { - lov = take2(fn(0, table) + ofs); - hiv = take2(fn(nr - 1, table) + ofs); - miv = take2(hash + ofs); - if (miv < lov) - return -1; - if (hiv < miv) - return index_pos_to_insert_pos(nr); - if (lov != hiv) { - /* - * At this point miv could be equal - * to hiv (but hash could still be higher); - * the invariant of (mi < hi) should be - * kept. - */ - mi = (nr - 1) * (miv - lov) / (hiv - lov); - if (lo <= mi && mi < hi) - break; - BUG("assertion failed in binary search"); - } - } - } - - do { - int cmp; - cmp = hashcmp(fn(mi, table), hash); - if (!cmp) - return mi; - if (cmp > 0) - hi = mi; - else - lo = mi + 1; - mi = lo + (hi - lo) / 2; - } while (lo < hi); - return index_pos_to_insert_pos(lo); -} - -int bsearch_hash(const unsigned char *sha1, const uint32_t *fanout_nbo, - const unsigned char *table, size_t stride, uint32_t *result) -{ - uint32_t hi, lo; - - hi = ntohl(fanout_nbo[*sha1]); - lo = ((*sha1 == 0x0) ? 0 : ntohl(fanout_nbo[*sha1 - 1])); - - while (lo < hi) { - unsigned mi = lo + (hi - lo) / 2; - int cmp = hashcmp(table + mi * stride, sha1); - - if (!cmp) { - if (result) - *result = mi; - return 1; - } - if (cmp > 0) - hi = mi; - else - lo = mi + 1; - } - - if (result) - *result = lo; - return 0; -} diff --git a/sha1-lookup.h b/sha1-lookup.h deleted file mode 100644 index 79973d4785..0000000000 --- a/sha1-lookup.h +++ /dev/null @@ -1,32 +0,0 @@ -#ifndef SHA1_LOOKUP_H -#define SHA1_LOOKUP_H - -typedef const unsigned char *hash_access_fn(size_t index, void *table); - -int hash_pos(const unsigned char *hash, - void *table, - size_t nr, - hash_access_fn fn); - -/* - * Searches for sha1 in table, using the given fanout table to determine the - * interval to search, then using binary search. Returns 1 if found, 0 if not. - * - * Takes the following parameters: - * - * - sha1: the hash to search for - * - fanout_nbo: a 256-element array of NETWORK-order 32-bit integers; the - * integer at position i represents the number of elements in table whose - * first byte is less than or equal to i - * - table: a sorted list of hashes with optional extra information in between - * - stride: distance between two consecutive elements in table (should be - * GIT_MAX_RAWSZ or greater) - * - result: if not NULL, this function stores the element index of the - * position found (if the search is successful) or the index of the least - * element that is greater than sha1 (if the search is not successful) - * - * This function does not verify the validity of the fanout table. - */ -int bsearch_hash(const unsigned char *sha1, const uint32_t *fanout_nbo, - const unsigned char *table, size_t stride, uint32_t *result); -#endif -- cgit v1.3-5-g9baa