-----------------------------------------------------------------------------

case 0:

-----------------------------------------------------------------------------

This is how you read a blob (actually, not only a blob, but any type of

works, find the source code for it (something like `git grep

read_object_with | grep ":[a-z]"` in the Git repository), and read

the source.

LIB_OBJS += object-file-convert.o

LIB_OBJS += object-file.o

LIB_OBJS += object-name.o

LIB_OBJS += object.o

LIB_OBJS += oid-array.o

LIB_OBJS += oidmap.o

LIB_OBJS += oidset.o

#include "abspath.h"

#include "base85.h"

#include "config.h"

#include "delta.h"

#include "diff.h"

#include "dir.h"

return 0; /* deletion patch */

}

/* We already have the postimage */

enum object_type type;

unsigned long size;

char *result;

if (!result)

return error(_("the necessary postimage %s for "

"'%s' cannot be read"),

unsigned long sz;

char *result;

if (!result)

return -1;

/* XXX read_sha1_file NUL-terminates */

image_clear(image);

if (!data || type != OBJ_BLOB)

die("unable to read blob object %s", oid_to_hex(result_id));

strbuf_attach(&image->buf, data, size, size + 1);

#include "hex.h"

#include "tar.h"

#include "archive.h"

#include "strbuf.h"

#include "streaming.h"

#include "run-command.h"

#include "hex.h"

#include "streaming.h"

#include "utf8.h"

#include "strbuf.h"

#include "userdiff.h"

#include "write-or-die.h"

#include "pretty.h"

#include "setup.h"

#include "refs.h"

#include "commit.h"

#include "tree.h"

#include "tree-walk.h"

(args->tree ? &args->tree->object.oid : NULL), oid);

path += args->baselen;

if (buffer && S_ISREG(mode)) {

struct strbuf buf = STRBUF_INIT;

size_t size = 0;

/* Stream it? */

if (S_ISREG(mode) && !args->convert &&

size > repo_settings_get_big_file_threshold(the_repository))

return write_entry(args, oid, path.buf, path.len, mode, NULL, size);

#include "read-cache-ll.h"

#include "refs.h"

#include "revision.h"

#include "setup.h"

#include "thread-utils.h"

#include "tree-walk.h"

if (get_tree_entry(istate->repo, tree_oid, path, &oid, &mode))

return NULL;

if (!buf || type != OBJ_BLOB) {

free(buf);

return NULL;

#include "commit-slab.h"

#include "commit-reach.h"

#include "object-name.h"

#include "path.h"

#include "dir.h"

unsigned commit_flags = commit->object.flags;

enum object_type type;

unsigned long size;

const char *subject_start;

int subject_len;

#include "git-compat-util.h"

#include "refs.h"

#include "cache-tree.h"

#include "mergesort.h"

#include "commit.h"

unsigned short mode;

if (!get_tree_entry(r, commit_oid, path, &blob_oid, &mode) &&

return;

}

convert_to_git(r->index, path, buf.buf, buf.len, &buf, 0);

origin->file.ptr = buf.buf;

origin->file.size = buf.len;

/*

* Read the current index, replace the path entry with

&o->blob_oid, 1, &file->ptr, &file_size))

;

else

file->size = file_size;

if (!file->ptr)

return 0;

if (get_tree_entry(r, &origin->commit->object.oid, origin->path, &origin->blob_oid, &origin->mode))

goto error_out;

goto error_out;

return 0;

error_out:

&sb->final_buf_size))

;

else

if (!sb->final_buf)

die(_("cannot read blob %s for path %s"),

#include "tree.h"

#include "tree-walk.h"

#include "object.h"

#include "oid-array.h"

#include "oidset.h"

#include "promisor-remote.h"

return 0;

for (size_t i = 0; i < list->nr; i++) {

oid_array_append(&ctx->current_batch, &list->oid[i]);

}

#include "line-log.h"

#include "progress.h"

#include "object-name.h"

#include "pager.h"

#include "blame.h"

#include "refs.h"

if (repo_get_oid(the_repository, name, &oid))

return 0;

}

static int peel_to_commit_oid(struct object_id *oid_ret, void *cbdata)

oidcpy(&oid, oid_ret);

while (1) {

struct object *obj;

if (kind == OBJ_COMMIT) {

oidcpy(oid_ret, &oid);

return 0;

#include "pack-bitmap.h"

#include "object-file.h"

#include "object-name.h"

#include "replace-object.h"

#include "promisor-remote.h"

#include "mailmap.h"

{

enum object_type type;

if (!*buf)

return error(_("cannot read object %s '%s'"),

oid_to_hex(oid), path);

switch (opt) {

case 't':

oi.typep = &type;

die("git cat-file: could not get object info");

printf("%s\n", type_name(type));

ret = 0;

oi.contentp = (void**)&buf;

}

die("git cat-file: could not get object info");

if (use_mailmap && (type == OBJ_COMMIT || type == OBJ_TAG)) {

goto cleanup;

case 'e':

goto cleanup;

case 'w':

/* else fallthrough */

case 'p':

if (type < 0)

die("Not a valid object name %s", obj_name);

ret = stream_blob(&oid);

goto cleanup;

}

if (!buf)

die("Cannot read object %s", obj_name);

if (exp_type_id == OBJ_BLOB) {

struct object_id blob_oid;

const char *target;

if (!buffer)

} else

oidcpy(&blob_oid, &oid);

ret = stream_blob(&blob_oid);

goto cleanup;

}

* fall-back to the usual case.

*/

}

if (use_mailmap) {

size_t s = size;

/*

* After a mark_query run, this object_info is set up to be

* elements above, so you can retrieve the response from there.

*/

struct object_info info;

if (!textconv_object(the_repository,

data->rest, 0100644, oid,

1, &contents, &size))

if (!contents)

die("could not convert '%s' %s",

oid_to_hex(oid), data->rest);

unsigned long size;

void *contents;

if (!contents)

die("object %s disappeared", oid_to_hex(oid));

data->info.sizep = &data->size;

if (pack)

else

if (ret < 0) {

if (data->mode == S_IFGITLINK)

report_object_status(opt, oid_to_hex(&data->oid), &data->oid, "submodule");

size_t s = data->size;

char *buf = NULL;

if (!buf)

die(_("unable to read %s"), oid_to_hex(&data->oid));

buf = replace_idents_using_mailmap(buf, &s);

/*

* Expand once with our special mark_query flag, which will prime the

* object.

*/

data.mark_query = 1;

#include "merge-ort-wrappers.h"

#include "object-file.h"

#include "object-name.h"

#include "parse-options.h"

#include "path.h"

#include "preload-index.h"

#include "refs.h"

#include "refspec.h"

#include "object-file.h"

#include "tree.h"

#include "tree-walk.h"

#include "unpack-trees.h"

} else {

struct strbuf sb = STRBUF_INIT;

strbuf_addf(&sb, "%s/objects", ref_git);

strbuf_release(&sb);

}

if (!line.len || line.buf[0] == '#')

continue;

if (is_absolute_path(line.buf)) {

continue;

}

abs_path = mkpathdup("%s/objects/%s", src_repo, line.buf);

if (!normalize_path_copy(abs_path, abs_path))

else

warning("skipping invalid relative alternate: %s/%s",

src_repo, line.buf);

struct strbuf alt = STRBUF_INIT;

get_common_dir(&alt, src_repo);

strbuf_addstr(&alt, "/objects");

strbuf_release(&alt);

} else {

struct strbuf src = STRBUF_INIT;

continue;

if (ends_with(ref->name, "^{}"))

continue;

continue;

refs_update_ref(get_main_ref_store(the_repository), msg,

ref->name, &ref->old_oid, NULL, 0,

#include "hex.h"

#include "parse-options.h"

#include "commit-graph.h"

#include "progress.h"

#include "replace-object.h"

#include "strbuf.h"

struct repository *repo UNUSED)

{

struct commit_graph *graph = NULL;

char *graph_name;

char *chain_name;

enum { OPENED_NONE, OPENED_GRAPH, OPENED_CHAIN } opened = OPENED_NONE;

if (opts.progress)

flags |= COMMIT_GRAPH_WRITE_PROGRESS;

if (open_commit_graph(graph_name, &fd, &st))

opened = OPENED_GRAPH;

else if (errno != ENOENT)

if (opened == OPENED_NONE)

return 0;

else if (opened == OPENED_GRAPH)

else

graph = load_commit_graph_chain_fd_st(the_repository, fd, &st,

&incomplete_chain);

struct string_list pack_indexes = STRING_LIST_INIT_DUP;

struct strbuf buf = STRBUF_INIT;

struct oidset commits = OIDSET_INIT;

int result = 0;

enum commit_graph_write_flags flags = 0;

struct progress *progress = NULL;

git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0))

flags |= COMMIT_GRAPH_WRITE_BLOOM_FILTERS;

if (opts.reachable) {

result = 1;

goto cleanup;

}

stop_progress(&progress);

}

opts.stdin_packs ? &pack_indexes : NULL,

opts.stdin_commits ? &commits : NULL,

flags,

#include "gettext.h"

#include "hex.h"

#include "object-name.h"

#include "commit.h"

#include "parse-options.h"

if (repo_get_oid_commit(the_repository, arg, &oid))

die(_("not a valid object name %s"), arg);

new_parent(lookup_commit(the_repository, &oid), parents);

return 0;

}

return 0;

}

{

printf("alternate: ");

putchar('\n');

return 0;

}

printf("prune-packable: %lu\n", packed_loose);

printf("garbage: %lu\n", garbage);

printf("size-garbage: %s\n", garbage_buf.buf);

strbuf_release(&loose_buf);

strbuf_release(&pack_buf);

strbuf_release(&garbage_buf);

#include "setup.h"

#include "strvec.h"

#include "run-command.h"

#include "list-objects.h"

#include "commit-slab.h"

#include "wildmatch.h"

if (cmit)

describe_commit(&oid, &sb);

describe_blob(oid, &sb);

else

die(_("%s is neither a commit nor blob"), arg);

#include "strbuf.h"

#include "lockfile.h"

#include "object-file.h"

#include "dir.h"

#include "entry.h"

#include "setup.h"

} else {

enum object_type type;

unsigned long size;

if (!data)

die(_("could not read object %s for symlink %s"),

oid_to_hex(oid), path);

#include "refs.h"

#include "refspec.h"

#include "object-file.h"

#include "commit.h"

#include "object.h"

#include "tag.h"

object = (struct object *)lookup_blob(the_repository, oid);

eaten = 0;

} else {

if (!buf)

die("could not read blob %s", oid_to_hex(oid));

if (check_object_signature(the_repository, oid, buf, size,

return;

}

if (!buf)

die("could not read tag %s", oid_to_hex(&tag->object.oid));

message = memmem(buf, size, "\n\n", 2);

if (last_idnum < mark)

last_idnum = mark;

if (type < 0)

die("object not found: %s", oid_to_hex(&oid));

#include "packfile.h"

#include "object-file.h"

#include "object-name.h"

#include "mem-pool.h"

#include "commit-reach.h"

#include "khash.h"

struct packed_git *p;

int pack_fd;

FLEX_ALLOC_STR(p, pack_name, tmp_file.buf);

strbuf_release(&tmp_file);

die("Can't load tree %s", oid_to_hex(oid));

} else {

enum object_type type;

if (!buf || type != OBJ_TREE)

die("Can't load tree %s", oid_to_hex(oid));

}

struct object_entry *e;

e = find_object(oid);

if (!e) {

if (type < 0)

die("object not found: %s", oid_to_hex(oid));

e = insert_object(oid);

enum object_type expected = S_ISDIR(mode) ?

OBJ_TREE: OBJ_BLOB;

enum object_type type = oe ? oe->type :

if (type < 0)

die("%s not found: %s",

S_ISDIR(mode) ? "Tree" : "Blob",

oidcpy(&commit_oid, &commit_oe->idx.oid);

} else if (!repo_get_oid(the_repository, p, &commit_oid)) {

unsigned long size;

if (!buf || size < the_hash_algo->hexsz + 6)

die("Not a valid commit: %s", p);

free(buf);

die("Not a blob (actually a %s): %s",

type_name(oe->type), command_buf.buf);

} else if (!is_null_oid(&oid)) {

NULL);

if (type < 0)

die("Blob not found: %s", command_buf.buf);

unsigned long size;

char *buf;

parse_from_commit(b, buf, size);

free(buf);

}

oidcpy(&n->oid, &oe->idx.oid);

} else if (!repo_get_oid(the_repository, from, &n->oid)) {

unsigned long size;

if (!buf || size < the_hash_algo->hexsz + 6)

die("Not a valid commit: %s", from);

free(buf);

} else if (!repo_get_oid(the_repository, from, &oid)) {

struct object_entry *oe = find_object(&oid);

if (!oe) {

if (type < 0)

die("Not a valid object: %s", from);

} else

char *buf;

if (!oe || oe->pack_id == MAX_PACK_ID) {

} else {

type = oe->type;

buf = gfi_unpack_entry(oe, &size);

const unsigned hexsz = the_hash_algo->hexsz;

if (!oe) {

if (type < 0)

die("object not found: %s", oid_to_hex(oid));

/* cache it! */

buf = gfi_unpack_entry(oe, &size);

} else {

enum object_type unused;

}

if (!buf)

die("Can't load object %s", oid_to_hex(oid));

#include "refs.h"

#include "refspec.h"

#include "object-name.h"

#include "oidset.h"

#include "oid-array.h"

#include "commit.h"

*/

if (ends_with(ref->name, "^{}")) {

if (item &&

!oidset_contains(&fetch_oids, &ref->old_oid) &&

!oidset_contains(&fetch_oids, &item->oid))

clear_item(item);

item = NULL;

* fetch.

*/

if (item &&

!oidset_contains(&fetch_oids, &item->oid))

clear_item(item);

* checked to see if it needs fetching.

*/

if (item &&

!oidset_contains(&fetch_oids, &item->oid))

clear_item(item);

struct commit *current = NULL, *updated;

int fast_forward = 0;

die(_("object %s not found"), oid_to_hex(&ref->new_oid));

if (oideq(&ref->old_oid, &ref->new_oid)) {

* we need all direct targets to exist.

*/

for (r = rm; r; r = r->next) {

return -1;

}

struct object_id oid;

if (repo_get_oid(the_repository, s, &oid))

die(_("%s is not a valid object"), s);

die(_("the object %s does not exist"), s);

oid_array_append(oids, &oid);

continue;

commit_graph_flags |= COMMIT_GRAPH_WRITE_PROGRESS;

trace2_region_enter("fetch", "write-commit-graph", the_repository);

commit_graph_flags,

NULL);

trace2_region_leave("fetch", "write-commit-graph", the_repository);

#include "packfile.h"

#include "object-file.h"

#include "object-name.h"

#include "path.h"

#include "read-cache-ll.h"

#include "replace-object.h"

const char *ret;

if (type == OBJ_NONE)

ret = type_name(type);

if (!ret)

return 0;

if (!(obj->flags & HAS_OBJ)) {

printf_ln(_("broken link from %7s %s\n"

" to %7s %s"),

printable_type(&parent->oid, parent->type),

* (and we want to avoid parsing blobs).

*/

if (obj->type == OBJ_NONE) {

if (type > 0)

object_as_type(obj, type, 0);

}

struct repository *repo UNUSED)

{

int i;

/* fsck knows how to handle missing promisor objects */

fetch_if_missing = 0;

for_each_packed_object(the_repository,

mark_packed_for_connectivity, NULL, 0);

} else {

if (check_full) {

struct packed_git *p;

if (the_repository->settings.core_commit_graph) {

struct child_process commit_graph_verify = CHILD_PROCESS_INIT;

child_process_init(&commit_graph_verify);

commit_graph_verify.git_cmd = 1;

strvec_pushl(&commit_graph_verify.args, "commit-graph",

if (show_progress)

strvec_push(&commit_graph_verify.args, "--progress");

else

if (the_repository->settings.core_multi_pack_index) {

struct child_process midx_verify = CHILD_PROCESS_INIT;

child_process_init(&midx_verify);

midx_verify.git_cmd = 1;

strvec_pushl(&midx_verify.args, "multi-pack-index",

if (show_progress)

strvec_push(&midx_verify.args, "--progress");

else

}

if (the_repository->settings.gc_write_commit_graph == 1)

!opts.quiet && !daemonized ? COMMIT_GRAPH_WRITE_PROGRESS : 0,

NULL);

if (!peel_iterated_oid(the_repository, oid, &peeled))

oid = &peeled;

return 0;

commit = lookup_commit(the_repository, oid);

if (loose_object_auto_limit < 0)

return 1;

loose_object_count,

NULL, NULL, &count);

}

* Do not start pack-objects process

* if there are no loose objects.

*/

bail_on_loose,

NULL, NULL, NULL))

return 0;

strvec_push(&pack_proc.args, "--quiet");

else

strvec_push(&pack_proc.args, "--no-quiet");

pack_proc.in = -1;

else if (data.batch_size > 0)

data.batch_size--; /* Decrease for equality on limit. */

write_loose_object_to_stdin,

NULL,

NULL,

int result = 0;

struct lock_file lk;

struct repository *r = the_repository;

if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) {

/*

unsigned int i;

int result = 0;

struct lock_file lk;

if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) {

if (errno == EEXIST)

#include "submodule-config.h"

#include "object-file.h"

#include "object-name.h"

#include "packfile.h"

#include "pager.h"

#include "path.h"

/*

* NEEDSWORK: repo_read_gitmodules() might call

* operation causes a race condition with concurrent object readings

* performed by the worker threads. That's why we need obj_read_lock()

* here. It should be removed once it's no longer necessary to add the

* lazily registered as alternates when needed (and except in an

* unexpected code interaction, it won't be needed).

*/

obj_read_unlock();

memcpy(&subopt, opt, sizeof(subopt));

struct strbuf base = STRBUF_INIT;

obj_read_lock();

obj_read_unlock();

if (!data)

die(_("unable to read tree (%s)"), oid_to_hex(oid));

void *data;

unsigned long size;

if (!data)

die(_("unable to read tree %s"), oid_to_hex(&ce->oid));

init_tree_desc(&tree, &ce->oid, data, size);

void *data;

unsigned long size;

if (!data)

die(_("unable to read tree (%s)"),

oid_to_hex(&entry.oid));

struct strbuf base;

int hit, len;

if (!data)

die(_("unable to read tree (%s)"), oid_to_hex(&obj->oid));

#include "gettext.h"

#include "hex.h"

#include "object-file.h"

#include "blob.h"

#include "quote.h"

#include "parse-options.h"

#include "packfile.h"

#include "pack-revindex.h"

#include "object-file.h"

#include "oid-array.h"

#include "oidset.h"

#include "path.h"

if (!(obj->flags & FLAG_CHECKED)) {

unsigned long size;

if (type <= 0)

die(_("did not receive expected object %s"),

oid_to_hex(&obj->oid));

input_fd = 0;

if (!pack_name) {

struct strbuf tmp_file = STRBUF_INIT;

"pack/tmp_pack_XXXXXX");

pack_name = strbuf_detach(&tmp_file, NULL);

} else {

if (startup_info->have_repository) {

read_lock();

read_unlock();

}

enum object_type has_type;

unsigned long has_size;

read_lock();

if (has_type < 0)

die(_("cannot read existing object info %s"), oid_to_hex(oid));

if (has_type != type || has_size != size)

die(_("SHA1 COLLISION FOUND WITH %s !"), oid_to_hex(oid));

read_unlock();

if (!data)

data = new_data = get_data_from_pack(obj_entry);

struct oid_array to_fetch = OID_ARRAY_INIT;

for (i = 0; i < nr_ref_deltas; i++) {

struct ref_delta_entry *d = sorted_by_pos[i];

continue;

oid_array_append(&to_fetch, &d->oid);

}

if (objects[d->obj_no].real_type != OBJ_REF_DELTA)

continue;

if (!data)

continue;

oidset_iter_init(&outgoing_links, &iter);

while ((oid = oidset_iter_next(&iter))) {

struct object_info info = OBJECT_INFO_INIT;

/* Missing; assume it is a promisor object */

continue;

if (info.whence == OI_PACKED && info.u.packed.pack->pack_promisor)

#include "hex.h"

#include "refs.h"

#include "object-name.h"

#include "pager.h"

#include "color.h"

#include "commit.h"

{

unsigned long size;

enum object_type type;

unsigned long offset = 0;

if (!buf)

#include "setup.h"

#include "sparse-index.h"

#include "submodule.h"

#include "hex.h"

{

if (type == OBJ_BLOB) {

unsigned long size;

die(_("could not get object info about '%s'"),

oid_to_hex(oid));

if (padded)

#include "gettext.h"

#include "hex.h"

#include "object-name.h"

#include "tree.h"

#include "path.h"

#include "quote.h"

{

if (type == OBJ_BLOB) {

unsigned long size;

die(_("could not get object info about '%s'"),

oid_to_hex(oid));

if (padded)

if (type == OBJ_BLOB) {

unsigned long size;

xsnprintf(size_text, sizeof(size_text), "BAD");

else

xsnprintf(size_text, sizeof(size_text),

#include "hex.h"

#include "object-file.h"

#include "object-name.h"

#include "config.h"

#include "gettext.h"

#include "setup.h"

#include "commit-reach.h"

#include "merge-ort.h"

#include "object-name.h"

#include "parse-options.h"

#include "blob.h"

#include "merge-blobs.h"

const char *path = entry->path;

if (!entry->stage)

base = NULL;

if (entry->stage == 1) {

base = entry->blob;

enum object_type type;

while (entry) {

if (entry->stage == 2)

entry = entry->link;

}

return NULL;

#include "strbuf.h"

#include "replace-object.h"

#include "object-file.h"

#include "fsck.h"

#include "config.h"

void *buffer;

const struct object_id *repl;

if (!buffer)

die(_("could not read tagged object '%s'"),

oid_to_hex(tagged_oid));

#include "tree.h"

#include "parse-options.h"

#include "object-file.h"

static struct treeent {

unsigned mode;

/* Check the type of object identified by oid without fetching objects */

oi.typep = &obj_type;

obj_type = -1;

if (obj_type < 0) {

#include "midx.h"

#include "strbuf.h"

#include "trace2.h"

#include "replace-object.h"

#include "repository.h"

if (the_repository &&

the_repository->objects &&

argc = parse_options(argc, argv, prefix, options,

builtin_multi_pack_index_usage, 0);

#include "notes.h"

#include "object-file.h"

#include "object-name.h"

#include "path.h"

#include "pretty.h"

{

unsigned long size;

enum object_type type;

if (buf) {

if (size)

write_or_die(fd, buf, size);

strbuf_init(&msg->buf, 0);

if (repo_get_oid(the_repository, arg, &object))

die(_("failed to resolve '%s' as a valid ref."), arg);

die(_("failed to read object '%s'."), arg);

if (type != OBJ_BLOB) {

strbuf_release(&msg->buf);

unsigned long size;

enum object_type type;

struct strbuf buf = STRBUF_INIT;

if (!prev_buf)

die(_("unable to read %s"), oid_to_hex(note));

#include "list.h"

#include "packfile.h"

#include "object-file.h"

#include "replace-object.h"

#include "dir.h"

#include "midx.h"

void *buf, *base_buf, *delta_buf;

enum object_type type;

if (!buf)

die(_("unable to read %s"), oid_to_hex(&entry->idx.oid));

if (!base_buf)

die("unable to read %s",

oid_to_hex(&DELTA(entry)->idx.oid));

&size, NULL)) != NULL)

buf = NULL;

else {

if (!buf)

die(_("unable to read %s"),

oid_to_hex(&entry->idx.oid));

/* Did not find one. Either we got a bogus request or

* we need to read and perhaps cache.

*/

if (!data)

return NULL;

if (type != OBJ_TREE) {

if (window <= num_preferred_base++)

return;

if (!data)

return;

for (i = object_index_start; i < to_pack.nr_objects; i++) {

struct object_entry *entry = to_pack.objects + i;

continue;

oid_array_append(&to_fetch, &entry->idx.oid);

}

/*

* No choice but to fall back to the recursive delta walk

* at this point...

*/

give_up:

unuse_pack(&w_curs);

}

if (repo_has_promisor_remote(the_repository)) {

prefetch_to_pack(object_index);

type = -1;

} else {

type = -1;

if (packed_object_info(the_repository, IN_PACK(entry), entry->in_pack_offset, &oi) < 0) {

/*

* We failed to get the info from this pack for some reason;

* And if that fails, the error will be recorded in oe_type(entry)

* and dealt with in prepare_pack().

*/

oe_set_type(entry,

} else {

oe_set_type(entry, type);

}

if (e->type_ != OBJ_OFS_DELTA && e->type_ != OBJ_REF_DELTA) {

packing_data_lock(&to_pack);

die(_("unable to get size of %s"),

oid_to_hex(&e->idx.oid));

packing_data_unlock(&to_pack);

/* Load data if not already done */

if (!trg->data) {

packing_data_lock(&to_pack);

packing_data_unlock(&to_pack);

if (!trg->data)

die(_("object %s cannot be read"),

}

if (!src->data) {

packing_data_lock(&to_pack);

packing_data_unlock(&to_pack);

if (!src->data) {

if (src_entry->preferred_base) {

* Quietly ignore ALL missing objects. This avoids problems with

* staging them now and getting an odd error later.

*/

return;

show_object(obj, name, data);

* Quietly ignore EXPECTED missing objects. This avoids problems with

* staging them now and getting an odd error later.

*/

is_promisor_object(to_pack.repo, &obj->oid))

return;

static int add_loose_object(const struct object_id *oid, const char *path,

void *data UNUSED)

{

if (type < 0) {

warning(_("loose object at %s could not be examined"), path);

static int is_not_in_promisor_pack_obj(struct object *obj, void *data UNUSED)

{

struct object_info info = OBJECT_INFO_INIT;

BUG("should_include_obj should only be called on existing objects");

return info.whence != OI_PACKED || !info.u.packed.pack->pack_promisor;

}

#include "hex.h"

#include "packfile.h"

#include "strbuf.h"

#define BLKSIZE 512

#include "replace-object.h"

#include "object-file.h"

#include "object-name.h"

#include "shallow.h"

static const char * const prune_usage[] = {

if (st.st_mtime > expire)

return 0;

if (show_only || verbose) {

printf("%s %s\n", oid_to_hex(oid),

(type > 0) ? type_name(type) : "unknown");

}

#include "packfile.h"

#include "object-file.h"

#include "object-name.h"

#include "path.h"

#include "protocol.h"

#include "commit-reach.h"

refs_for_each_fullref_in(get_main_ref_store(the_repository), "",

exclude_patterns, show_ref_cb, &seen);

oidset_clear(&seen);

strvec_clear(&excludes_vector);

}

if (!is_null_oid(new_oid) &&

error("unpack should have generated %s, "

"but I can't find it!", oid_to_hex(new_oid));

ret = "bad pack";

#include "rebase.h"

#include "refs.h"

#include "refspec.h"

#include "strvec.h"

#include "commit-reach.h"

#include "progress.h"

info->status = PUSH_STATUS_UPTODATE;

else if (is_null_oid(&ref->old_oid))

info->status = PUSH_STATUS_CREATE;

ref_newer(&ref->new_oid, &ref->old_oid))

info->status = PUSH_STATUS_FASTFORWARD;

else

#include "midx.h"

#include "packfile.h"

#include "prune-packed.h"

#include "promisor-remote.h"

#include "shallow.h"

#include "pack.h"

if (oidset_insert(&data->seen, oid))

return 0; /* already seen */

return 0;

fprintf(data->f->fp, "%s%s\n", data->preferred ? "+" : "",

if (write_bitmaps && !(pack_everything & ALL_INTO_ONE) && !write_midx)

die(_(incremental_bitmap_conflict_error));

/*

* When asked to do a local repack, but we have

* packfiles that are inherited from an alternate, then

#include "run-command.h"

#include "object-file.h"

#include "object-name.h"

#include "replace-object.h"

#include "tag.h"

#include "wildmatch.h"

if (repo_get_oid(data->repo, refname, &object))

return error(_("failed to resolve '%s' as a valid ref"), refname);

printf("%s (%s) -> %s (%s)\n", refname, type_name(obj_type),

oid_to_hex(oid), type_name(repl_type));

struct strbuf err = STRBUF_INIT;

int res = 0;

if (!force && obj_type != repl_type)

return error(_("Objects must be of the same type.\n"

"'%s' points to a replaced object of type '%s'\n"

if (repo_get_oid(the_repository, object_ref, &old_oid) < 0)

return error(_("not a valid object name: '%s'"), object_ref);

if (type < 0)

return error(_("unable to get object type for %s"),

oid_to_hex(&old_oid));

#include "object.h"

#include "object-name.h"

#include "object-file.h"

#include "pack-bitmap.h"

#include "parse-options.h"

#include "log-tree.h"

off_t size;

struct object_info oi = OBJECT_INFO_INIT;

oi.disk_sizep = &size;

die(_("unable to get disk usage of %s"), oid_to_hex(&obj->oid));

return size;

}

static int finish_object(struct object *obj, const char *name, void *cb_data)

{

struct rev_list_info *info = cb_data;

finish_object__ma(obj, name);

return 1;

}

#include "hex.h"

#include "refs/refs-internal.h"

#include "object-name.h"

#include "object.h"

#include "string-list.h"

#include "parse-options.h"

const char *hex;

struct object_id peeled;

die("git show-ref: bad ref %s (%s)", refname,

oid_to_hex(oid));

#include "diff.h"

#include "object-file.h"

#include "object-name.h"

#include "advice.h"

#include "branch.h"

#include "list-objects-filter-options.h"

);

static int add_possible_reference_from_superproject(

{

struct submodule_alternate_setup *sas = sas_cb;

size_t len;

* If the alternate object store is another repository, try the

* standard layout with .git/(modules/<name>)+/objects

*/

struct repository alternate;

char *sm_alternate;

struct strbuf sb = STRBUF_INIT;

struct strbuf err = STRBUF_INIT;

if (repo_init(&alternate, sb.buf, NULL) < 0)

die(_("could not get a repository handle for gitdir '%s'"),

die(_("Value '%s' for submodule.alternateErrorStrategy is not recognized"), error_strategy);

if (!strcmp(sm_alternate, "superproject"))

else if (!strcmp(sm_alternate, "no"))

; /* do nothing */

else

#include "refs.h"

#include "object-file.h"

#include "object-name.h"

#include "path.h"

#include "tag.h"

#include "parse-options.h"

struct strbuf payload = STRBUF_INIT;

struct strbuf signature = STRBUF_INIT;

if (!buf)

return;

if (parse_signature(buf, size, &payload, &signature)) {

struct strbuf header = STRBUF_INIT;

int should_edit;

if (type <= OBJ_NONE)

die(_("bad object type."));

}

strbuf_addstr(sb, " (");

switch (type) {

default:

strbuf_addstr(sb, "object of unknown type");

break;

case OBJ_COMMIT:

subject_len = find_commit_subject(buf, &subject_start);

strbuf_insert(sb, sb->len, subject_start, subject_len);

} else {

#include "hex.h"

#include "object-file.h"

#include "object-name.h"

static char *create_temp_file(struct object_id *oid)

{

unsigned long size;

int fd;

if (!buf || type != OBJ_BLOB)

die("unable to read blob object %s", oid_to_hex(oid));

#include "git-zlib.h"

#include "hex.h"

#include "object-file.h"

#include "object.h"

#include "delta.h"

#include "pack.h"

if (!(obj->flags & FLAG_OPEN)) {

unsigned long size;

if (type != obj->type || type <= 0)

die("object of unexpected type");

obj->flags |= FLAG_WRITTEN;

delta_data = get_data(delta_size);

if (!delta_data)

return;

; /* Ok we have this one */

else if (resolve_against_held(nr, &base_oid,

delta_data, delta_size))

if (resolve_against_held(nr, &base_oid, delta_data, delta_size))

return;

if (!base) {

error("failed to read delta-pack base object %s",

oid_to_hex(&base_oid));

#include "tmp-objdir.h"

#include "packfile.h"

#include "object-file.h"

static int odb_transaction_nesting;

static int already_written(struct bulk_checkin_packfile *state, struct object_id *oid)

{

/* The object may already exist in the repository */

return 1;

/* Might want to keep the list sorted */

#include "fetch-pack.h"

#include "remote.h"

#include "trace2.h"

static struct {

enum bundle_list_heuristic heuristic;

* Find a temporary filename that is available. This is briefly

* racy, but unlikely to collide.

*/

if (fd < 0) {

warning(_("failed to create temporary file"));

return NULL;

#include "environment.h"

#include "gettext.h"

#include "hex.h"

#include "repository.h"

#include "object.h"

#include "commit.h"

.quiet = 1,

};

return error(_("need a repository to verify a bundle"));

for (i = 0; i < p->nr; i++) {

if (revs->max_age == -1 && revs->min_age == -1)

goto out;

if (!buf)

goto out;

line = memmem(buf, size, "\ntagger ", 8);

#include "cache-tree.h"

#include "bulk-checkin.h"

#include "object-file.h"

#include "read-cache-ll.h"

#include "replace-object.h"

#include "repository.h"

if (!it)

return 0;

if (it->entry_count < 0 ||

return 0;

for (i = 0; i < it->subtree_nr; i++) {

if (!cache_tree_fully_valid(it->down[i]->cache_tree))

}

if (0 <= it->entry_count &&

return it->entry_count;

/*

ce_missing_ok = mode == S_IFGITLINK || missing_ok ||

!must_check_existence(ce);

if (is_null_oid(oid) ||

strbuf_release(&buffer);

if (expected_missing)

return -1;

struct object_id oid;

hash_object_file(the_hash_algo, buffer.buf, buffer.len,

OBJ_TREE, &oid);

oidcpy(&it->oid, &oid);

else

to_invalidate = 1;

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

#include "commit.h"

#include "convert.h"

#include "diff.h"

*size = fill_textconv(r, textconv, df, &blob);

free_filespec(df);

} else {

if (!blob)

die(_("unable to read %s"), oid_to_hex(oid));

if (type != OBJ_BLOB)

#include "refs.h"

#include "hash-lookup.h"

#include "commit-graph.h"

#include "oid-array.h"

#include "path.h"

#include "alloc.h"

if (git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0))

flags = COMMIT_GRAPH_WRITE_BLOOM_FILTERS;

flags, NULL))

die("failed to write commit-graph under GIT_TEST_COMMIT_GRAPH");

}

return 0;

}

{

}

const char *oid_hex)

{

oid_hex);

}

{

}

static struct commit_graph *alloc_commit_graph(void)

struct commit_graph *load_commit_graph_one_fd_st(struct repository *r,

int fd, struct stat *st,

{

void *graph_map;

size_t graph_size;

ret = parse_commit_graph(&r->settings, graph_map, graph_size);

if (ret)

else

munmap(graph_map, graph_size);

static struct commit_graph *load_commit_graph_one(struct repository *r,

const char *graph_file,

{

struct stat st;

if (!open_ok)

return NULL;

if (g)

g->filename = xstrdup(graph_file);

}

static struct commit_graph *load_commit_graph_v1(struct repository *r,

{

free(graph_name);

return g;

count = st->st_size / (the_hash_algo->hexsz + 1);

CALLOC_ARRAY(oids, count);

for (i = 0; i < count; i++) {

if (strbuf_getline_lf(&line, fp) == EOF)

break;

}

valid = 0;

free(graph_name);

}

static struct commit_graph *load_commit_graph_chain(struct repository *r,

{

struct stat st;

int fd;

struct commit_graph *g = NULL;

}

struct commit_graph *read_commit_graph_one(struct repository *r,

{

if (!g)

return g;

}

static void prepare_commit_graph_one(struct repository *r,

{

if (r->objects->commit_graph)

return;

}

/*

*/

static int prepare_commit_graph(struct repository *r)

{

/*

* Early return if there is no git dir or if the commit graph is

if (!commit_graph_compatible(r))

return 0;

return !!r->objects->commit_graph;

}

return NULL;

}

{

if (!o->commit_graph)

return;

return NULL;

if (!search_commit_pos_in_graph(id, repo->objects->commit_graph, &pos))

return NULL;

return NULL;

commit = lookup_commit(repo, id);

struct write_commit_graph_context {

struct repository *r;

char *graph_name;

struct oid_array oids;

struct packed_commit_list commits;

if (!peel_iterated_oid(the_repository, oid, &peeled))

oid = &peeled;

oidset_insert(data->commits, oid);

display_progress(data->progress, oidset_size(data->commits));

return 0;

}

enum commit_graph_write_flags flags,

const struct commit_graph_opts *opts)

{

stop_progress(&data.progress);

flags, opts);

oidset_clear(&commits);

int dirlen;

int ret = 0;

dirlen = packname.len;

if (ctx->report_progress) {

strbuf_addf(&progress_title,

strbuf_addf(&tmp_file,

"%s/info/commit-graphs/tmp_graph_XXXXXX",

ctx->graph_name = strbuf_detach(&tmp_file, NULL);

} else {

}

if (safe_create_leading_directories(the_repository, ctx->graph_name)) {

}

if (ctx->split) {

hold_lock_file_for_update_mode(&lk, lock_name,

LOCK_DIE_ON_ERROR, 0444);

if (ctx->split && ctx->base_graph_name && ctx->num_commit_graphs_after > 1) {

char *new_base_hash = xstrdup(oid_to_hex(&ctx->new_base_graph->oid));

free(ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 2]);

free(ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 2]);

}

}

} else {

unlink(graph_name);

free(graph_name);

}

free(ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1]);

ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1] = xstrdup(hash_to_hex(file_hash));

ctx->commit_graph_hash_after[ctx->num_commit_graphs_after - 1]);

free(ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 1]);

ctx->commit_graph_filenames_after[ctx->num_commit_graphs_after - 1] = final_graph_name;

flags != COMMIT_GRAPH_SPLIT_REPLACE) {

while (g && (g->num_commits <= st_mult(size_mult, num_commits) ||

(max_commits && num_commits > max_commits))) {

break;

if (unsigned_add_overflows(num_commits, g->num_commits))

"should be 1 with --split=replace");

if (ctx->num_commit_graphs_after == 2) {

if (!strcmp(g->filename, old_graph_name) &&

ctx->num_commit_graphs_after = 1;

ctx->new_base_graph = NULL;

}

if (ctx->opts && ctx->opts->expire_time)

expire_time = ctx->opts->expire_time;

if (!ctx->split) {

unlink(chain_file_name);

free(chain_file_name);

ctx->num_commit_graphs_after = 0;

}

strbuf_addstr(&path, "/info/commit-graphs");

dir = opendir(path.buf);

strbuf_release(&path);

}

const struct string_list *const pack_indexes,

struct oidset *commits,

enum commit_graph_write_flags flags,

struct repository *r = the_repository;

struct write_commit_graph_context ctx = {

.r = r,

.append = flags & COMMIT_GRAPH_WRITE_APPEND ? 1 : 0,

.report_progress = flags & COMMIT_GRAPH_WRITE_PROGRESS ? 1 : 0,

.split = flags & COMMIT_GRAPH_WRITE_SPLIT ? 1 : 0,

#ifndef COMMIT_GRAPH_H

#define COMMIT_GRAPH_H

#include "oidset.h"

#define GIT_TEST_COMMIT_GRAPH "GIT_TEST_COMMIT_GRAPH"

struct commit;

struct bloom_filter_settings;

struct repository;

struct string_list;

int open_commit_graph(const char *graph_file, int *fd, struct stat *st);

int open_commit_graph_chain(const char *chain_file, int *fd, struct stat *st);

uint32_t num_commits;

struct object_id oid;

char *filename;

uint32_t num_commits_in_base;

unsigned int read_generation_data;

struct commit_graph *load_commit_graph_one_fd_st(struct repository *r,

int fd, struct stat *st,

struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r,

int fd, struct stat *st,

int *incomplete_chain);

struct commit_graph *read_commit_graph_one(struct repository *r,

struct repo_settings;

* is not compatible with the commit-graph feature, then the

* methods will return 0 without writing a commit-graph.

*/

enum commit_graph_write_flags flags,

const struct commit_graph_opts *opts);

const struct string_list *pack_indexes,

struct oidset *commits,

enum commit_graph_write_flags flags,

int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags);

void free_commit_graph(struct commit_graph *);

/*

#include "hex.h"

#include "repository.h"

#include "object-name.h"

#include "utf8.h"

#include "diff.h"

#include "revision.h"

if (!ret) {

enum object_type type;

unsigned long size;

if (!ret)

die("cannot read commit object %s",

oid_to_hex(&commit->object.oid));

if (commit_graph_paranoia == -1)

commit_graph_paranoia = git_env_bool(GIT_COMMIT_GRAPH_PARANOIA, 0);

unparse_commit(r, &item->object.oid);

return quiet_on_missing ? -1 :

error(_("commit %s exists in commit-graph but not in the object database"),

return 0;

}

return quiet_on_missing ? -1 :

error("Could not read %s",

oid_to_hex(&item->object.oid));

desc = merge_remote_util(parent);

if (!desc || !desc->obj)

return;

if (!buf || type != OBJ_TAG)

goto free_return;

if (!parse_signature(buf, size, &payload, &signature))

/* Not having i18n.commitencoding is the same as having utf-8 */

encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);

if (memchr(msg, '\0', msg_len))

return error("a NUL byte in commit log message not allowed.");

#include "hashmap.h"

#include "string-list.h"

#include "object-name.h"

#include "pager.h"

#include "path.h"

#include "utf8.h"

unsigned long size;

int ret;

if (!buf)

return error(_("unable to load config blob object '%s'"), name);

if (type != OBJ_BLOB) {

#include "git-compat-util.h"

#include "gettext.h"

#include "hex.h"

#include "run-command.h"

#include "sigchain.h"

#include "connected.h"

|

- diff_setup

+ repo_diff_setup

|

- read_object_file

+ repo_read_object_file

#include "gettext.h"

#include "hex.h"

#include "strvec.h"

#include "packfile.h"

#include "parse-options.h"

#include "repository.h"

(uintmax_t)st.st_size);

}

{

struct strbuf *buf = data;

data);

return 0;

strbuf_reset(&buf);

strbuf_addstr(&buf, "--add-virtual-file=packs-local.txt:");

strvec_push(&archiver_args, buf.buf);

strbuf_reset(&buf);

#include "color.h"

#include "run-command.h"

#include "utf8.h"

#include "userdiff.h"

#include "submodule.h"

#include "hashmap.h"

info.contentp = &s->data;

if (options && options->missing_object_cb) {

goto object_read;

options->missing_object_cb(options->missing_object_data);

}

die("unable to read %s", oid_to_hex(&s->oid));

object_read:

}

if (!info.contentp) {

info.contentp = &s->data;

die("unable to read %s", oid_to_hex(&s->oid));

}

s->should_free = 1;

{

if (filespec && filespec->oid_valid &&

!S_ISGITLINK(filespec->mode) &&

oid_array_append(to_fetch, &filespec->oid);

}

*size_out = 0;

*data_out = NULL;

if (!data || type != OBJ_BLOB) {

free(data);

return -1;

#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"

#include "dir.h"

#include "environment.h"

#include "gettext.h"

{

enum object_type type;

unsigned long ul;

*size = ul;

if (blob_data) {

#include "oid-array.h"

#include "oidset.h"

#include "packfile.h"

#include "path.h"

#include "connected.h"

#include "fetch-negotiator.h"

size_t i;

if (!initialized) {

initialized = 1;

}

commit = lookup_commit_in_graph(the_repository, oid);

if (commit) {

if (mark_tags_complete_and_check_obj_db) {

die_in_commit_graph_only(oid);

}

return commit;

}

while (1) {

return NULL;

if (type == OBJ_TAG) {

struct tag *tag = (struct tag *)

if (!commit) {

struct object *o;

continue;

o = parse_object(the_repository, &ref->old_oid);

if (!o || o->type != OBJ_COMMIT)

struct oid_array extra = OID_ARRAY_INIT;

struct object_id *oid = si->shallow->oid;

for (i = 0; i < si->shallow->nr; i++)

oid_array_append(&extra, &oid[i]);

if (extra.nr) {

setup_alternate_shallow(&shallow_lock,

#include "environment.h"

#include "refs.h"

#include "object-name.h"

#include "diff.h"

#include "diff-merges.h"

#include "hex.h"

struct object_id *oid = origins.items[i].util;

enum object_type type;

unsigned long size;

char *origbuf = buf;

unsigned long len = size;

struct signature_check sigc = { NULL };

#include "date.h"

#include "dir.h"

#include "hex.h"

#include "path.h"

#include "repository.h"

#include "object.h"

if (oidset_contains(blobs_done, oid))

continue;

if (!buf) {

if (is_promisor_object(the_repository, oid))

continue;

#include "gettext.h"

#include "grep.h"

#include "hex.h"

#include "pretty.h"

#include "userdiff.h"

#include "xdiff-interface.h"

{

enum object_type type;

if (!gs->buf)

return error(_("'%s': unable to read %s"),

gs->name,

#include "url.h"

#include "strvec.h"

#include "packfile.h"

#include "protocol.h"

#include "date.h"

#include "write-or-die.h"

#include "url.h"

#include "packfile.h"

#include "object-file.h"

#include "commit-reach.h"

#ifdef EXPAT_NEEDS_XMLPARSE_H

ssize_t size;

git_zstream stream;

hdrlen = format_object_header(hdr, sizeof(hdr), type, len);

/* Set it up */

* may be required for updating server info later.

*/

if (repo->can_update_info_refs &&

obj = lookup_unknown_object(the_repository, &ref->old_oid);

fprintf(stderr, " fetch %s for %s\n",

oid_to_hex(&ref->old_oid), refname);

return error("Remote HEAD symrefs too deep");

if (is_null_oid(&head_oid))

return error("Unable to resolve remote HEAD");

return error("Remote HEAD resolves to object %s\nwhich does not exist locally, perhaps you need to fetch?", oid_to_hex(&head_oid));

/* Remote branch must resolve to a known object */

if (is_null_oid(&remote_ref->old_oid))

return error("Unable to resolve remote branch %s",

remote_ref->name);

return error("Remote branch %s resolves to object %s\nwhich does not exist locally, perhaps you need to fetch?", remote_ref->name, oid_to_hex(&remote_ref->old_oid));

/* Remote branch must be an ancestor of remote HEAD */

if (!force_all &&

!is_null_oid(&ref->old_oid) &&

!ref->force) {

!ref_newer(&ref->peer_ref->new_oid,

&ref->old_oid)) {

/*

#include "transport.h"

#include "packfile.h"

#include "object-file.h"

struct alt_base {

char *base;

list_for_each_safe(pos, tmp, head) {

obj_req = list_entry(pos, struct object_request, node);

if (obj_req->state == WAITING) {

obj_req->state = COMPLETE;

else {

start_object_request(obj_req);

if (!obj_req)

return error("Couldn't find request for %s in the queue", hex);

if (obj_req->req)

abort_http_object_request(&obj_req->req);

abort_object_request(obj_req);

ret = error("File %s has bad hash", hex);

} else if (req->rename < 0) {

struct strbuf buf = STRBUF_INIT;

ret = error("unable to write sha1 filename %s", buf.buf);

strbuf_release(&buf);

}

#include "packfile.h"

#include "string-list.h"

#include "object-file.h"

#include "tempfile.h"

static struct trace_key trace_curl = TRACE_KEY_INIT(CURL);

oidcpy(&freq->oid, oid);

freq->localfile = -1;

strbuf_addf(&freq->tmpfile, "%s.temp", filename.buf);

strbuf_addf(&prevfile, "%s.prev", filename.buf);

unlink_or_warn(freq->tmpfile.buf);

return -1;

}

freq->rename = finalize_object_file(freq->tmpfile.buf, filename.buf);

strbuf_release(&filename);

#include "oidmap.h"

#include "oidset.h"

#include "object-name.h"

/* Remember to update object flag allocation in object.h */

/*

assert(obj->type == OBJ_BLOB);

assert((obj->flags & SEEN) == 0);

if (t != OBJ_BLOB) { /* probably OBJ_NONE */

/*

* We DO NOT have the blob locally, so we cannot

#include "list-objects-filter.h"

#include "list-objects-filter-options.h"

#include "packfile.h"

#include "trace.h"

#include "environment.h"

* of missing objects.

*/

if (ctx->revs->exclude_promisor_objects &&

is_promisor_object(ctx->revs->repo, &obj->oid))

return;

return 0;

}

if (objtype < 0)

return 0;

obj = lookup_object_by_type(the_repository, oid, objtype);

#include "git-compat-util.h"

#include "hash.h"

#include "path.h"

#include "hex.h"

#include "repository.h"

#include "wrapper.h"

return 1;

}

const struct object_id *oid,

const struct object_id *compat_oid)

{

int inserted = 0;

inserted |= insert_oid_pair(map->to_compat, oid, compat_oid);

inserted |= insert_oid_pair(map->to_storage, compat_oid, oid);

if (inserted)

return inserted;

}

{

struct strbuf buf = STRBUF_INIT, path = STRBUF_INIT;

FILE *fp;

}

repo_common_path_replace(repo, &path, "objects/loose-object-idx");

fp = fopen(path.buf, "rb");

parse_oid_hex_algop(p, &compat_oid, &p, repo->compat_hash_algo) ||

p != buf.buf + buf.len)

goto err;

}

strbuf_release(&buf);

int repo_read_loose_object_map(struct repository *repo)

{

if (!should_use_loose_object_map(repo))

return 0;

return -1;

}

}

int repo_write_loose_object_map(struct repository *repo)

{

struct lock_file lock;

int fd;

khiter_t iter;

if (!should_use_loose_object_map(repo))

return 0;

if (inserted)

return write_one_object(repo, oid, compat_oid);

return 0;

const struct git_hash_algo *to,

struct object_id *dest)

{

kh_oid_map_t *map;

khiter_t pos;

if (!loose_map)

continue;

map = (to == repo->compat_hash_algo) ?

#include "string-list.h"

#include "mailmap.h"

#include "object-name.h"

#include "setup.h"

char *git_mailmap_file;

if (repo_get_oid(the_repository, name, &oid) < 0)

return 0;

if (!buf)

return error("unable to read mailmap object at %s", name);

if (type != OBJ_BLOB) {

#include "tree.h"

#include "tree-walk.h"

#include "object-file.h"

#include "repository.h"

static int score_missing(unsigned mode)

enum object_type type;

unsigned long size;

if (!buffer)

die("unable to read tree (%s)", oid_to_hex(hash));

if (type != OBJ_TREE)

if (*subpath)

subpath++;

if (!buf)

die("cannot read tree %s", oid_to_hex(oid1));

init_tree_desc(&desc, oid1, buf, sz);

#include "merge-ll.h"

#include "blob.h"

#include "merge-blobs.h"

static int fill_mmfile_blob(mmfile_t *f, struct blob *obj)

{

unsigned long size;

enum object_type type;

if (!buf)

return -1;

if (type != OBJ_BLOB) {

return NULL;

if (!our)

our = their;

}

if (fill_mmfile_blob(&f1, our) < 0)

#include "mem-pool.h"

#include "object-file.h"

#include "object-name.h"

#include "oid-array.h"

#include "path.h"

#include "promisor-remote.h"

void *buf;

enum object_type type;

unsigned long size;

if (!buf) {

path_msg(opt, ERROR_OBJECT_READ_FAILED, 0,

path, NULL, NULL, NULL,

if ((ci->filemask & side_mask) &&

S_ISREG(vi->mode) &&

oid_array_append(&to_fetch, &vi->oid);

}

}

'object-file-convert.c',

'object-file.c',

'object-name.c',

'object.c',

'oid-array.c',

'oidmap.c',

'oidset.c',

struct strbuf cur_path_real = STRBUF_INIT;

/* Ensure the given object_dir is local, or a known alternate. */

for (cur = get_multi_pack_index(r); cur; cur = cur->next) {

strbuf_realpath(&cur_path_real, cur->object_dir, 1);

{

struct strbuf midx = STRBUF_INIT;

if (r->objects && r->objects->multi_pack_index) {

close_midx(r->objects->multi_pack_index);

if (remove_path(midx.buf))

die(_("failed to clear multi-pack-index at %s"), midx.buf);

strbuf_release(&midx);

}

#include "git-compat-util.h"

#include "notes-cache.h"

#include "object-file.h"

#include "pretty.h"

#include "repository.h"

#include "commit.h"

value_oid = get_note(&c->tree, key_oid);

if (!value_oid)

return NULL;

*outsize = size;

return value;

#include "refs.h"

#include "object-file.h"

#include "object-name.h"

#include "path.h"

#include "repository.h"

#include "diff.h"

{

enum object_type type;

unsigned long size;

if (!buf)

die("cannot read note %s for object %s",

#include "notes.h"

#include "object-file.h"

#include "object-name.h"

#include "utf8.h"

#include "strbuf.h"

#include "tree-walk.h"

struct note_delete_list **l = (struct note_delete_list **) cb_data;

struct note_delete_list *n;

return 0; /* nothing to do for this note */

/* failed to find object => prune this note */

/* read in both note blob objects */

if (!is_null_oid(new_oid))

if (!new_msg || !new_len || new_type != OBJ_BLOB) {

free(new_msg);

return 0;

}

if (!is_null_oid(cur_oid))

if (!cur_msg || !cur_len || cur_type != OBJ_BLOB) {

free(cur_msg);

free(new_msg);

return 0;

/* read_sha1_file NUL-terminates */

if (t != OBJ_BLOB || !data || !len) {

free(data);

return t != OBJ_BLOB || !data;

if (!oid)

return;

free(msg);

return;

}

#include "loose.h"

#include "object-file-convert.h"

#include "object-file.h"

#include "oidtree.h"

#include "pack.h"

#include "packfile.h"

}

}

struct strbuf *buf,

const struct object_id *oid)

{

strbuf_reset(buf);

strbuf_addch(buf, '/');

fill_loose_path(buf, oid);

return buf->buf;

return 1;

}

const struct object_id *oid,

int freshen)

{

static struct strbuf path = STRBUF_INIT;

return check_and_freshen_file(path.buf, freshen);

}

static int check_and_freshen_local(const struct object_id *oid, int freshen)

{

}

static int check_and_freshen_nonlocal(const struct object_id *oid, int freshen)

{

return 1;

}

return 0;

static int stat_loose_object(struct repository *r, const struct object_id *oid,

struct stat *st, const char **path)

{

static struct strbuf buf = STRBUF_INIT;

if (!lstat(*path, st))

return 0;

}

const struct object_id *oid, const char **path)

{

int fd;

int most_interesting_errno = ENOENT;

static struct strbuf buf = STRBUF_INIT;

fd = git_open(*path);

if (fd >= 0)

return fd;

static int quick_has_loose(struct repository *r,

const struct object_id *oid)

{

return 1;

}

return 0;

/* Finalize a file on disk, and close it. */

static void close_loose_object(int fd, const char *filename)

{

goto out;

if (batch_fsync_enabled(FSYNC_COMPONENT_LOOSE_OBJECT))

if (batch_fsync_enabled(FSYNC_COMPONENT_LOOSE_OBJECT))

prepare_loose_object_bulk_checkin();

fd = start_loose_object_common(&tmp_file, filename.buf, flags,

&stream, compressed, sizeof(compressed),

goto cleanup;

}

/* We finally know the object path, and create the missing dir. */

dirlen = directory_size(filename.buf);

oi.typep = &type;

oi.sizep = &len;

oi.contentp = &buf;

return error(_("cannot read object for %s"), oid_to_hex(oid));

if (compat) {

if (repo_oid_to_algop(repo, oid, compat, &compat_oid))

int for_each_loose_object(each_loose_object_fn cb, void *data,

enum for_each_object_flags flags)

{

NULL, data);

if (r)

return r;

return 0;

}

{

int subdir_nr = oid->hash[0];

struct strbuf buf = STRBUF_INIT;

size_t word_index = subdir_nr / word_bits;

size_t mask = (size_t)1u << (subdir_nr % word_bits);

uint32_t *bitmap;

if (subdir_nr < 0 ||

BUG("subdir_nr out of range");

if (*bitmap & mask)

}

for_each_file_in_obj_subdir(subdir_nr, &buf,

append_loose_object,

NULL, NULL,

*bitmap |= mask;

strbuf_release(&buf);

}

{

}

static int check_stream_oid(git_zstream *stream,

#include "git-zlib.h"

#include "object.h"

struct index_state;

/*

* blobs. This has a difference only if extensions.partialClone is set.

*

* Its default value is 1.

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 index_path(struct index_state *istate, struct object_id *oid, const char *path, struct stat *st, unsigned flags);

/*

* Populate and return the loose object cache array corresponding to the

* given object ID.

*/

const struct object_id *oid);

/* Empty the loose object cache for the specified object directory. */

/*

* Put in `buf` the name of the file in the local object database that

* would be used to store a loose object with the specified oid.

*/

struct strbuf *buf,

const struct object_id *oid);

static void find_short_object_filename(struct disambiguate_state *ds)

{

&ds->bin_pfx, ds->len, match_prefix, ds);

}

const struct object_id *oid,

void *cb_data UNUSED)

{

return kind == OBJ_COMMIT;

}

struct object *obj;

int kind;

if (kind == OBJ_COMMIT)

return 1;

if (kind != OBJ_TAG)

const struct object_id *oid,

void *cb_data UNUSED)

{

return kind == OBJ_TREE;

}

struct object *obj;

int kind;

if (kind == OBJ_TREE || kind == OBJ_COMMIT)

return 1;

if (kind != OBJ_TAG)

const struct object_id *oid,

void *cb_data UNUSED)

{

return kind == OBJ_BLOB;

}

ds->hex_pfx[len] = '\0';

ds->repo = r;

ds->bin_pfx.algo = algo ? hash_algo_by_ptr(algo) : GIT_HASH_UNKNOWN;

return 0;

}

return 0;

hash = repo_find_unique_abbrev(ds->repo, oid, DEFAULT_ABBREV);

if (type < 0) {

/*

{

struct repository *sort_ambiguous_repo = ctx;

const struct object_id *a = va, *b = vb;

int a_type_sort;

int b_type_sort;

struct object *o = lookup_unknown_object(r, name);

if (o->type == OBJ_NONE) {

if (type < 0 || !object_as_type(o, type, 0))

return PEEL_INVALID;

}

}

if ((!obj || obj->type == OBJ_BLOB) &&

if (!skip_hash && stream_object_signature(r, repl) < 0) {

error(_("hash mismatch %s"), oid_to_hex(oid));

return NULL;

*/

if (skip_hash && discard_tree &&

(!obj || obj->type == OBJ_TREE) &&

return &lookup_tree(r, oid)->object;

}

if (buffer) {

if (!skip_hash &&

check_object_signature(r, repl, buffer, size, type) < 0) {

#include "git-compat-util.h"

#include "abspath.h"

#include "commit-graph.h"

#include "loose.h"

#include "object-file-convert.h"

#include "object-file.h"

#include "packfile.h"

#include "path.h"

#include "promisor-remote.h"

#include "strbuf.h"

#include "strvec.h"

#include "submodule.h"

#include "write-or-die.h"

KHASH_INIT(odb_path_map, const char * /* key: odb_path */,

/*

* This is meant to hold a *small* number of objects that you would

* to write them into the object store (e.g. a browse-only

* application).

*/

} value;

};

const struct object_id *oid)

{

static const struct cached_object empty_tree = {

return NULL;

}

{

int fd;

/*

* restrictive except to remove write permission.

*/

int mode = 0444;

fd = git_mkstemp_mode(temp_filename->buf, mode);

if (0 <= fd)

return fd;

/* slow path */

/* some mkstemp implementations erase temp_filename on failure */

return xmkstemp_mode(temp_filename->buf, mode);

}

/*

* Return non-zero iff the path is usable as an alternate object database.

*/

struct strbuf *path,

const char *normalized_objdir, khiter_t *pos)

{

* Prevent the common mistake of listing the same

* thing twice, or object directory itself.

*/

khiter_t p;

assert(r == 1); /* never used */

}

if (fspatheq(path->buf, normalized_objdir))

return 0;

/* r: 0 = exists, 1 = never used, 2 = deleted */

return r == 0 ? 0 : 1;

}

* Prepare alternate object database registry.

*

* The variable alt_odb_list points at the list of struct

* 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

* of the object ID, an extra slash for the first level indirection, and

* the terminating NUL.

*/

const char *relative_base,

int depth);

{

struct strbuf pathbuf = STRBUF_INIT;

struct strbuf tmp = STRBUF_INIT;

khiter_t pos;

while (pathbuf.len && pathbuf.buf[pathbuf.len - 1] == '/')

strbuf_setlen(&pathbuf, pathbuf.len - 1);

goto error;

/* add the alternate entry */

/* recursively add alternates */

ret = 0;

error:

strbuf_release(&tmp);

return end;

}

int sep, const char *relative_base, int depth)

{

struct strbuf objdirbuf = STRBUF_INIT;

return;

}

while (*alt) {

alt = parse_alt_odb_entry(alt, sep, &entry);

if (!entry.len)

continue;

relative_base, depth, objdirbuf.buf);

}

strbuf_release(&entry);

strbuf_release(&objdirbuf);

}

const char *relative_base,

int depth)

{

return;

}

strbuf_release(&buf);

free(path);

}

{

struct lock_file lock = LOCK_INIT;

FILE *in, *out;

int found = 0;

fprintf_or_die(out, "%s\n", reference);

if (commit_lock_file(&lock))

die_errno(_("unable to move new alternates file into place"));

'\n', NULL, 0);

}

free(alts);

}

{

/*

* Make sure alternates are initialized, or else our entry may be

* overwritten when they are.

*/

'\n', NULL, 0);

}

{

/*

* Make sure alternates are initialized, or else our entry may be

* overwritten when they are.

*/

/*

* Make a new primary odb and link the old primary ODB in as an

* alternate

*/

/*

* Disable ref updates while a temporary odb is active, since

* the objects in the database may roll back.

*/

}

{

}

{

BUG("expected %s as primary object store; found %s",

BUG("we expect the old primary object store to be the first alternate");

}

char *compute_alternate_path(const char *path, struct strbuf *err)

{

char *ref_git = NULL;

return ref_git;

}

{

char *obj_dir_real = real_pathdup(obj_dir, 1);

struct strbuf odb_path_real = STRBUF_INIT;

if (!strcmp(obj_dir_real, odb_path_real.buf))

break;

}

free(obj_dir_real);

strbuf_release(&odb_path_real);

die(_("could not find object directory matching %s"), obj_dir);

}

const char *repo_path)

{

const char *value;

cmd->use_shell = 1;

strvec_push(&cmd->args, value);

strvec_push(&cmd->args, "for-each-ref");

strvec_push(&cmd->args, "--format=%(objectname)");

strvec_push(&cmd->args, "--");

strvec_split(&cmd->args, value);

}

cmd->out = -1;

}

{

struct child_process cmd = CHILD_PROCESS_INIT;

struct strbuf line = STRBUF_INIT;

FILE *fh;

if (start_command(&cmd))

return;

struct object_id oid;

const char *p;

warning(_("invalid line while parsing alternate refs: %s"),

line.buf);

break;

}

}

fclose(fh);

}

struct alternate_refs_data {

};

{

struct strbuf path = STRBUF_INIT;

size_t base_len;

goto out;

if (!strbuf_strip_suffix(&path, "/objects"))

goto out;

goto out;

strbuf_setlen(&path, base_len);

out:

strbuf_release(&path);

return 0;

}

{

}

{

int r = 0;

if (r)

break;

}

return r;

}

{

return;

}

{

}

int obj_read_use_lock = 0;

int fetch_if_missing = 1;

const struct object_id *oid,

struct object_info *oi, unsigned flags)

{

if (flags & OBJECT_INFO_LOOKUP_REPLACE)

if (is_null_oid(real))

return -1;

if (!oi)

oi = &blank_oi;

if (co) {

if (oi->typep)

*(oi->typep) = co->type;

if (oi->disk_sizep)

*(oi->disk_sizep) = 0;

if (oi->delta_base_oid)

if (oi->contentp)

*oi->contentp = xmemdupz(co->buf, co->size);

oi->whence = OI_CACHED;

}

while (1) {

break;

/* Most likely it's a loose object. */

return 0;

/* Not a loose object; someone else may have just packed it. */

if (!(flags & OBJECT_INFO_QUICK)) {

break;

}

/*

*/

/* We added some alternates; retry */

continue;

/* Check if it is a missing object */

!already_retried &&

!(flags & OBJECT_INFO_SKIP_FETCH_OBJECT)) {

already_retried = 1;

continue;

}

if ((flags & OBJECT_INFO_LOOKUP_REPLACE) && !oideq(real, oid))

die(_("replacement %s not found for %s"),

oid_to_hex(real), oid_to_hex(oid));

die(_("packed object %s (stored in %s) is corrupt"),

oid_to_hex(real), p->pack_name);

}

* information below, so return early.

*/

return 0;

if (rtype < 0) {

mark_bad_packed_object(e.p, real);

} else if (oi->whence == OI_PACKED) {

oi->u.packed.offset = e.offset;

oi->u.packed.pack = e.p;

void *content;

int ret;

if (do_die)

die(_("missing mapping of %s to %s"),

return -1;

}

oi = &new_oi;

}

if (ret)

return -1;

if (oi == input_oi)

struct strbuf outbuf = STRBUF_INIT;

if (type != OBJ_BLOB) {

content, size, type, !do_die);

free(content);

if (ret == -1)

return ret;

}

{

int ret;

obj_read_lock();

obj_read_unlock();

return ret;

}

/* returns enum object_type or negative */

{

enum object_type type;

struct object_info oi = OBJECT_INFO_INIT;

oi.typep = &type;

oi.sizep = sizep;

return -1;

return type;

}

{

struct cached_object_entry *co;

char *co_buf;

return 0;

co->value.size = len;

co->value.type = type;

co_buf = xmalloc(len);

return 0;

}

{

struct object_info oi = OBJECT_INFO_INIT;

unsigned flags = OBJECT_INFO_DIE_IF_CORRUPT | OBJECT_INFO_LOOKUP_REPLACE;

oi.typep = type;

oi.sizep = size;

oi.contentp = &data;

return NULL;

return data;

}

{

enum object_type type;

void *buffer;

int ref_length = -1;

const char *ref_type = NULL;

if (!buffer)

return NULL;

if (type == required_type) {

}

ref_length = strlen(ref_type);

memcmp(buffer, ref_type, ref_length) ||

free(buffer);

return NULL;

}

}

}

unsigned flags)

{

unsigned object_info_flags = 0;

if (!(flags & HAS_OBJECT_FETCH_PROMISOR))

object_info_flags |= OBJECT_INFO_SKIP_FETCH_OBJECT;

}

{

if (type < 0)

die(_("%s is not a valid object"), oid_to_hex(oid));

if (type != expect)

type_name(expect));

}

{

memset(o, 0, sizeof(*o));

INIT_LIST_HEAD(&o->packed_git_mru);

hashmap_init(&o->pack_map, pack_map_entry_cmp, NULL, 0);

pthread_mutex_init(&o->replace_mutex, NULL);

return o;

}

{

}

}

{

FREE_AND_NULL(o->alternate_db);

o->commit_graph_attempted = 0;

free_object_directories(o);

o->loaded_alternates = 0;

for (size_t i = 0; i < o->cached_object_nr; i++)

o->packed_git = NULL;

hashmap_clear(&o->pack_map);

}

#include "git-compat-util.h"

#include "packfile.h"

int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);

#include "environment.h"

#include "gettext.h"

#include "hex.h"

#include "commit.h"

#include "diff.h"

#include "revision.h"

break;

default:

break;

}

struct bitmap_disk_header header;

if (writer->pseudo_merges_nr)

options |= BITMAP_OPT_PSEUDO_MERGES;

#include "packfile.h"

#include "repository.h"

#include "trace2.h"

#include "list-objects-filter-options.h"

#include "midx.h"

#include "config.h"

size_t eindex_pos = pos - bitmap_num_objects_total(bitmap_git);

struct eindex *eindex = &bitmap_git->ext_index;

struct object *obj = eindex->objects[eindex_pos];

die(_("unable to get size of %s"), oid_to_hex(&obj->oid));

}

i)))

continue;

die(_("unable to get disk usage of '%s'"),

oid_to_hex(&obj->oid));

#include "progress.h"

#include "packfile.h"

#include "object-file.h"

struct idx_entry {

off_t offset;

#include "git-compat-util.h"

#include "gettext.h"

#include "pack-mtimes.h"

#include "packfile.h"

#include "strbuf.h"

#ifndef PACK_OBJECTS_H

#define PACK_OBJECTS_H

#include "thread-utils.h"

#include "pack.h"

#include "packfile.h"