/*
 * Copyright (C) the libgit2 contributors. All rights reserved.
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */
#include "git2/indexer.h"
#include "git2/object.h"
#include "common.h"
#include "pack.h"
#include "mwindow.h"
#include "posix.h"
#include "pack.h"
#include "filebuf.h"
#include "oid.h"
#include "oidmap.h"
#include "zstream.h"
GIT__USE_OIDMAP
extern git_mutex git__mwindow_mutex;
#define UINT31_MAX (0x7FFFFFFF)
struct entry {
        git_oid oid;
        uint32_t crc;
        uint32_t offset;
        uint64_t offset_long;
};
struct git_indexer {
        unsigned int parsed_header :1,
                opened_pack :1,
                have_stream :1,
                have_delta :1;
        struct git_pack_header hdr;
        struct git_pack_file *pack;
        unsigned int mode;
        git_off_t off;
        git_off_t entry_start;
        git_packfile_stream stream;
        size_t nr_objects;
        git_vector objects;
        git_vector deltas;
        unsigned int fanout[256];
        git_hash_ctx hash_ctx;
        git_oid hash;
        git_transfer_progress_cb progress_cb;
        void *progress_payload;
        char objbuf[8*1024];
        /* Needed to look up objects which we want to inject to fix a thin pack */
        git_odb *odb;
        /* Fields for calculating the packfile trailer (hash of everything before it) */
        char inbuf[GIT_OID_RAWSZ];
        size_t inbuf_len;
        git_hash_ctx trailer;
};
struct delta_info {
        git_off_t delta_off;
};
const git_oid *git_indexer_hash(const git_indexer *idx)
{
        return &idx->hash;
}
static int parse_header(struct git_pack_header *hdr, struct git_pack_file *pack)
{
        int error;
        git_map map;
        if ((error = p_mmap(&map, sizeof(*hdr), GIT_PROT_READ, GIT_MAP_SHARED, pack->mwf.fd, 0)) < 0)
                return error;
        memcpy(hdr, map.data, sizeof(*hdr));
        p_munmap(&map);
        /* Verify we recognize this pack file format. */
        if (hdr->hdr_signature != ntohl(PACK_SIGNATURE)) {
                giterr_set(GITERR_INDEXER, "Wrong pack signature");
                return -1;
        }
        if (!pack_version_ok(hdr->hdr_version)) {
                giterr_set(GITERR_INDEXER, "Wrong pack version");
                return -1;
        }
        return 0;
}
static int objects_cmp(const void *a, const void *b)
{
        const struct entry *entrya = a;
        const struct entry *entryb = b;
        return git_oid__cmp(&entrya->oid, &entryb->oid);
}
int git_indexer_new(
                git_indexer **out,
                const char *prefix,
                unsigned int mode,
                git_odb *odb,
                git_transfer_progress_cb progress_cb,
                void *progress_payload)
{
        git_indexer *idx;
        git_buf path = GIT_BUF_INIT, tmp_path = GIT_BUF_INIT;
        static const char suff[] = "/pack";
        int error, fd = -1;
        idx = git__calloc(1, sizeof(git_indexer));
        GITERR_CHECK_ALLOC(idx);
        idx->odb = odb;
        idx->progress_cb = progress_cb;
        idx->progress_payload = progress_payload;
        idx->mode = mode ? mode : GIT_PACK_FILE_MODE;
        git_hash_ctx_init(&idx->hash_ctx);
        git_hash_ctx_init(&idx->trailer);
        error = git_buf_joinpath(&path, prefix, suff);
        if (error < 0)
                goto cleanup;
        fd = git_futils_mktmp(&tmp_path, git_buf_cstr(&path), idx->mode);
        git_buf_free(&path);
        if (fd < 0)
                goto cleanup;
        error = git_packfile_alloc(&idx->pack, git_buf_cstr(&tmp_path));
        git_buf_free(&tmp_path);
        if (error < 0)
                goto cleanup;
        idx->pack->mwf.fd = fd;
        if ((error = git_mwindow_file_register(&idx->pack->mwf)) < 0)
                goto cleanup;
        *out = idx;
        return 0;
cleanup:
        if (fd != -1)
                p_close(fd);
        git_buf_free(&path);
        git_buf_free(&tmp_path);
        git__free(idx);
        return -1;
}
/* Try to store the delta so we can try to resolve it later */
static int store_delta(git_indexer *idx)
{
        struct delta_info *delta;
        delta = git__calloc(1, sizeof(struct delta_info));
        GITERR_CHECK_ALLOC(delta);
        delta->delta_off = idx->entry_start;
        if (git_vector_insert(&idx->deltas, delta) < 0)
                return -1;
        return 0;
}
static void hash_header(git_hash_ctx *ctx, git_off_t len, git_otype type)
{
        char buffer[64];
        size_t hdrlen;
        hdrlen = git_odb__format_object_header(buffer, sizeof(buffer), (size_t)len, type);
        git_hash_update(ctx, buffer, hdrlen);
}
static int hash_object_stream(git_indexer*idx, git_packfile_stream *stream)
{
        ssize_t read;
        assert(idx && stream);
        do {
                if ((read = git_packfile_stream_read(stream, idx->objbuf, sizeof(idx->objbuf))) < 0)
                        break;
                git_hash_update(&idx->hash_ctx, idx->objbuf, read);
        } while (read > 0);
        if (read < 0)
                return (int)read;
        return 0;
}
/* In order to create the packfile stream, we need to skip over the delta base description */
static int advance_delta_offset(git_indexer *idx, git_otype type)
{
        git_mwindow *w = NULL;
        assert(type == GIT_OBJ_REF_DELTA || type == GIT_OBJ_OFS_DELTA);
        if (type == GIT_OBJ_REF_DELTA) {
                idx->off += GIT_OID_RAWSZ;
        } else {
                git_off_t base_off = get_delta_base(idx->pack, &w, &idx->off, type, idx->entry_start);
                git_mwindow_close(&w);
                if (base_off < 0)
                        return (int)base_off;
        }
        return 0;
}
/* Read from the stream and discard any output */
static int read_object_stream(git_indexer *idx, git_packfile_stream *stream)
{
        ssize_t read;
        assert(stream);
        do {
                read = git_packfile_stream_read(stream, idx->objbuf, sizeof(idx->objbuf));
        } while (read > 0);
        if (read < 0)
                return (int)read;
        return 0;
}
static int crc_object(uint32_t *crc_out, git_mwindow_file *mwf, git_off_t start, git_off_t size)
{
        void *ptr;
        uint32_t crc;
        unsigned int left, len;
        git_mwindow *w = NULL;
        crc = crc32(0L, Z_NULL, 0);
        while (size) {
                ptr = git_mwindow_open(mwf, &w, start, (size_t)size, &left);
                if (ptr == NULL)
                        return -1;
                len = min(left, (unsigned int)size);
                crc = crc32(crc, ptr, len);
                size -= len;
                start += len;
                git_mwindow_close(&w);
        }
        *crc_out = htonl(crc);
        return 0;
}
static int store_object(git_indexer *idx)
{
        int i, error;
        khiter_t k;
        git_oid oid;
        struct entry *entry;
        git_off_t entry_size;
        struct git_pack_entry *pentry;
        git_off_t entry_start = idx->entry_start;
        entry = git__calloc(1, sizeof(*entry));
        GITERR_CHECK_ALLOC(entry);
        pentry = git__calloc(1, sizeof(struct git_pack_entry));
        GITERR_CHECK_ALLOC(pentry);
        git_hash_final(&oid, &idx->hash_ctx);
        entry_size = idx->off - entry_start;
        if (entry_start > UINT31_MAX) {
                entry->offset = UINT32_MAX;
                entry->offset_long = entry_start;
        } else {
                entry->offset = (uint32_t)entry_start;
        }
        git_oid_cpy(&pentry->sha1, &oid);
        pentry->offset = entry_start;
        k = kh_put(oid, idx->pack->idx_cache, &pentry->sha1, &error);
        if (error == -1) {
                git__free(pentry);
                giterr_set_oom();
                goto on_error;
        }
        if (error == 0) {
                giterr_set(GITERR_INDEXER, "duplicate object %s found in pack", git_oid_tostr_s(&pentry->sha1));
                git__free(pentry);
                goto on_error;
        }
        kh_value(idx->pack->idx_cache, k) = pentry;
        git_oid_cpy(&entry->oid, &oid);
        if (crc_object(&entry->crc, &idx->pack->mwf, entry_start, entry_size) < 0)
                goto on_error;
        /* Add the object to the list */
        if (git_vector_insert(&idx->objects, entry) < 0)
                goto on_error;
        for (i = oid.id[0]; i < 256; ++i) {
                idx->fanout[i]++;
        }
        return 0;
on_error:
        git__free(entry);
        return -1;
}
GIT_INLINE(bool) has_entry(git_indexer *idx, git_oid *id)
{
        khiter_t k;
        k = kh_get(oid, idx->pack->idx_cache, id);
        return (k != kh_end(idx->pack->idx_cache));
}
static int save_entry(git_indexer *idx, struct entry *entry, struct git_pack_entry *pentry, git_off_t entry_start)
{
        int i, error;
        khiter_t k;
        if (entry_start > UINT31_MAX) {
                entry->offset = UINT32_MAX;
                entry->offset_long = entry_start;
        } else {
                entry->offset = (uint32_t)entry_start;
        }
        pentry->offset = entry_start;
        k = kh_put(oid, idx->pack->idx_cache, &pentry->sha1, &error);
        if (error <= 0) {
                giterr_set(GITERR_INDEXER, "cannot insert object into pack");
                return -1;
        }
        kh_value(idx->pack->idx_cache, k) = pentry;
        /* Add the object to the list */
        if (git_vector_insert(&idx->objects, entry) < 0)
                return -1;
        for (i = entry->oid.id[0]; i < 256; ++i) {
                idx->fanout[i]++;
        }
        return 0;
}
static int hash_and_save(git_indexer *idx, git_rawobj *obj, git_off_t entry_start)
{
        git_oid oid;
        size_t entry_size;
        struct entry *entry;
        struct git_pack_entry *pentry = NULL;
        entry = git__calloc(1, sizeof(*entry));
        GITERR_CHECK_ALLOC(entry);
        if (git_odb__hashobj(&oid, obj) < 0) {
                giterr_set(GITERR_INDEXER, "Failed to hash object");
                goto on_error;
        }
        pentry = git__calloc(1, sizeof(struct git_pack_entry));
        GITERR_CHECK_ALLOC(pentry);
        git_oid_cpy(&pentry->sha1, &oid);
        git_oid_cpy(&entry->oid, &oid);
        entry->crc = crc32(0L, Z_NULL, 0);
        entry_size = (size_t)(idx->off - entry_start);
        if (crc_object(&entry->crc, &idx->pack->mwf, entry_start, entry_size) < 0)
                goto on_error;
        return save_entry(idx, entry, pentry, entry_start);
on_error:
        git__free(pentry);
        git__free(entry);
        git__free(obj->data);
        return -1;
}
static int do_progress_callback(git_indexer *idx, git_transfer_progress *stats)
{
        if (idx->progress_cb)
                return giterr_set_after_callback_function(
                        idx->progress_cb(stats, idx->progress_payload),
                        "indexer progress");
        return 0;
}
/* Hash everything but the last 20B of input */
static void hash_partially(git_indexer *idx, const uint8_t *data, size_t size)
{
        size_t to_expell, to_keep;
        if (size == 0)
                return;
        /* Easy case, dump the buffer and the data minus the last 20 bytes */
        if (size >= GIT_OID_RAWSZ) {
                git_hash_update(&idx->trailer, idx->inbuf, idx->inbuf_len);
                git_hash_update(&idx->trailer, data, size - GIT_OID_RAWSZ);
                data += size - GIT_OID_RAWSZ;
                memcpy(idx->inbuf, data, GIT_OID_RAWSZ);
                idx->inbuf_len = GIT_OID_RAWSZ;
                return;
        }
        /* We can just append */
        if (idx->inbuf_len + size <= GIT_OID_RAWSZ) {
                memcpy(idx->inbuf + idx->inbuf_len, data, size);
                idx->inbuf_len += size;
                return;
        }
        /* We need to partially drain the buffer and then append */
        to_keep   = GIT_OID_RAWSZ - size;
        to_expell = idx->inbuf_len - to_keep;
        git_hash_update(&idx->trailer, idx->inbuf, to_expell);
        memmove(idx->inbuf, idx->inbuf + to_expell, to_keep);
        memcpy(idx->inbuf + to_keep, data, size);
        idx->inbuf_len += size - to_expell;
}
static int write_at(git_indexer *idx, const void *data, git_off_t offset, size_t size)
{
        git_file fd = idx->pack->mwf.fd;
        size_t page_size;
        size_t page_offset;
        git_off_t page_start;
        unsigned char *map_data;
        git_map map;
        int error;
        assert(data && size);
        if ((error = git__page_size(&page_size)) < 0)
                return error;
        /* the offset needs to be at the beginning of the a page boundary */
        page_offset = offset % page_size;
        page_start = offset - page_offset;
        if ((error = p_mmap(&map, page_offset + size, GIT_PROT_WRITE, GIT_MAP_SHARED, fd, page_start)) < 0)
                return error;
        map_data = (unsigned char *)map.data;
        memcpy(map_data + page_offset, data, size);
        p_munmap(&map);
        return 0;
}
static int append_to_pack(git_indexer *idx, const void *data, size_t size)
{
        git_off_t current_size = idx->pack->mwf.size;
        int fd = idx->pack->mwf.fd;
        if (!size)
                return 0;
        if (p_lseek(fd, current_size + size - 1, SEEK_SET) < 0 ||
            p_write(idx->pack->mwf.fd, data, 1) < 0) {
                giterr_set(GITERR_OS, "cannot extend packfile '%s'", idx->pack->pack_name);
                return -1;
        }
        return write_at(idx, data, idx->pack->mwf.size, size);
}
int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_transfer_progress *stats)
{
        int error = -1;
        size_t processed;
        struct git_pack_header *hdr = &idx->hdr;
        git_mwindow_file *mwf = &idx->pack->mwf;
        assert(idx && data && stats);
        processed = stats->indexed_objects;
        if ((error = append_to_pack(idx, data, size)) < 0)
                return error;
        hash_partially(idx, data, (int)size);
        /* Make sure we set the new size of the pack */
        idx->pack->mwf.size += size;
        if (!idx->parsed_header) {
                unsigned int total_objects;
                if ((unsigned)idx->pack->mwf.size < sizeof(struct git_pack_header))
                        return 0;
                if ((error = parse_header(&idx->hdr, idx->pack)) < 0)
                        return error;
                idx->parsed_header = 1;
                idx->nr_objects = ntohl(hdr->hdr_entries);
                idx->off = sizeof(struct git_pack_header);
                /* for now, limit to 2^32 objects */
                assert(idx->nr_objects == (size_t)((unsigned int)idx->nr_objects));
                if (idx->nr_objects == (size_t)((unsigned int)idx->nr_objects))
                        total_objects = (unsigned int)idx->nr_objects;
                else
                        total_objects = UINT_MAX;
                idx->pack->idx_cache = git_oidmap_alloc();
                GITERR_CHECK_ALLOC(idx->pack->idx_cache);
                idx->pack->has_cache = 1;
                if (git_vector_init(&idx->objects, total_objects, objects_cmp) < 0)
                        return -1;
                if (git_vector_init(&idx->deltas, total_objects / 2, NULL) < 0)
                        return -1;
                stats->received_objects = 0;
                stats->local_objects = 0;
                stats->total_deltas = 0;
                stats->indexed_deltas = 0;
                processed = stats->indexed_objects = 0;
                stats->total_objects = total_objects;
                if ((error = do_progress_callback(idx, stats)) != 0)
                        return error;
        }
        /* Now that we have data in the pack, let's try to parse it */
        /* As the file grows any windows we try to use will be out of date */
        git_mwindow_free_all(mwf);
        while (processed < idx->nr_objects) {
                git_packfile_stream *stream = &idx->stream;
                git_off_t entry_start = idx->off;
                size_t entry_size;
                git_otype type;
                git_mwindow *w = NULL;
                if (idx->pack->mwf.size <= idx->off + 20)
                        return 0;
                if (!idx->have_stream) {
                        error = git_packfile_unpack_header(&entry_size, &type, mwf, &w, &idx->off);
                        if (error == GIT_EBUFS) {
                                idx->off = entry_start;
                                return 0;
                        }
                        if (error < 0)
                                goto on_error;
                        git_mwindow_close(&w);
                        idx->entry_start = entry_start;
                        git_hash_init(&idx->hash_ctx);
                        if (type == GIT_OBJ_REF_DELTA || type == GIT_OBJ_OFS_DELTA) {
                                error = advance_delta_offset(idx, type);
                                if (error == GIT_EBUFS) {
                                        idx->off = entry_start;
                                        return 0;
                                }
                                if (error < 0)
                                        goto on_error;
                                idx->have_delta = 1;
                        } else {
                                idx->have_delta = 0;
                                hash_header(&idx->hash_ctx, entry_size, type);
                        }
                        idx->have_stream = 1;
                        error = git_packfile_stream_open(stream, idx->pack, idx->off);
                        if (error < 0)
                                goto on_error;
                }
                if (idx->have_delta) {
                        error = read_object_stream(idx, stream);
                } else {
                        error = hash_object_stream(idx, stream);
                }
                idx->off = stream->curpos;
                if (error == GIT_EBUFS)
                        return 0;
                /* We want to free the stream reasorces no matter what here */
                idx->have_stream = 0;
                git_packfile_stream_free(stream);
                if (error < 0)
                        goto on_error;
                if (idx->have_delta) {
                        error = store_delta(idx);
                } else {
                        error = store_object(idx);
                }
                if (error < 0)
                        goto on_error;
                if (!idx->have_delta) {
                        stats->indexed_objects = (unsigned int)++processed;
                }
                stats->received_objects++;
                if ((error = do_progress_callback(idx, stats)) != 0)
                        goto on_error;
        }
        return 0;
on_error:
        git_mwindow_free_all(mwf);
        return error;
}
static int index_path(git_buf *path, git_indexer *idx, const char *suffix)
{
        const char prefix[] = "pack-";
        size_t slash = (size_t)path->size;
        /* search backwards for '/' */
        while (slash > 0 && path->ptr[slash - 1] != '/')
                slash--;
        if (git_buf_grow(path, slash + 1 + strlen(prefix) +
                                         GIT_OID_HEXSZ + strlen(suffix) + 1) < 0)
                return -1;
        git_buf_truncate(path, slash);
        git_buf_puts(path, prefix);
        git_oid_fmt(path->ptr + git_buf_len(path), &idx->hash);
        path->size += GIT_OID_HEXSZ;
        git_buf_puts(path, suffix);
        return git_buf_oom(path) ? -1 : 0;
}
/**
 * Rewind the packfile by the trailer, as we might need to fix the
 * packfile by injecting objects at the tail and must overwrite it.
 */
static void seek_back_trailer(git_indexer *idx)
{
        idx->pack->mwf.size -= GIT_OID_RAWSZ;
        git_mwindow_free_all(&idx->pack->mwf);
}
static int inject_object(git_indexer *idx, git_oid *id)
{
        git_odb_object *obj;
        struct entry *entry;
        struct git_pack_entry *pentry = NULL;
        git_oid foo = {{0}};
        unsigned char hdr[64];
        git_buf buf = GIT_BUF_INIT;
        git_off_t entry_start;
        const void *data;
        size_t len, hdr_len;
        int error;
        seek_back_trailer(idx);
        entry_start = idx->pack->mwf.size;
        if (git_odb_read(&obj, idx->odb, id) < 0) {
                giterr_set(GITERR_INDEXER, "missing delta bases");
                return -1;
        }
        data = git_odb_object_data(obj);
        len = git_odb_object_size(obj);
        entry = git__calloc(1, sizeof(*entry));
        GITERR_CHECK_ALLOC(entry);
        entry->crc = crc32(0L, Z_NULL, 0);
        /* Write out the object header */
        hdr_len = git_packfile__object_header(hdr, len, git_odb_object_type(obj));
        if ((error = append_to_pack(idx, hdr, hdr_len)) < 0)
                goto cleanup;
        idx->pack->mwf.size += hdr_len;
        entry->crc = crc32(entry->crc, hdr, (uInt)hdr_len);
        if ((error = git_zstream_deflatebuf(&buf, data, len)) < 0)
                goto cleanup;
        /* And then the compressed object */
        if ((error = append_to_pack(idx, buf.ptr, buf.size)) < 0)
                goto cleanup;
        idx->pack->mwf.size += buf.size;
        entry->crc = htonl(crc32(entry->crc, (unsigned char *)buf.ptr, (uInt)buf.size));
        git_buf_free(&buf);
        /* Write a fake trailer so the pack functions play ball */
        if ((error = append_to_pack(idx, &foo, GIT_OID_RAWSZ)) < 0)
                goto cleanup;
        idx->pack->mwf.size += GIT_OID_RAWSZ;
        pentry = git__calloc(1, sizeof(struct git_pack_entry));
        GITERR_CHECK_ALLOC(pentry);
        git_oid_cpy(&pentry->sha1, id);
        git_oid_cpy(&entry->oid, id);
        idx->off = entry_start + hdr_len + len;
        error = save_entry(idx, entry, pentry, entry_start);
cleanup:
        if (error) {
                git__free(entry);
                git__free(pentry);
        }
        git_odb_object_free(obj);
        return error;
}
static int fix_thin_pack(git_indexer *idx, git_transfer_progress *stats)
{
        int error, found_ref_delta = 0;
        unsigned int i;
        struct delta_info *delta;
        size_t size;
        git_otype type;
        git_mwindow *w = NULL;
        git_off_t curpos = 0;
        unsigned char *base_info;
        unsigned int left = 0;
        git_oid base;
        assert(git_vector_length(&idx->deltas) > 0);
        if (idx->odb == NULL) {
                giterr_set(GITERR_INDEXER, "cannot fix a thin pack without an ODB");
                return -1;
        }
        /* Loop until we find the first REF delta */
        git_vector_foreach(&idx->deltas, i, delta) {
                if (!delta)
                        continue;
                curpos = delta->delta_off;
                error = git_packfile_unpack_header(&size, &type, &idx->pack->mwf, &w, &curpos);
                git_mwindow_close(&w);
                if (error < 0)
                        return error;
                if (type == GIT_OBJ_REF_DELTA) {
                        found_ref_delta = 1;
                        break;
                }
        }
        if (!found_ref_delta) {
                giterr_set(GITERR_INDEXER, "no REF_DELTA found, cannot inject object");
                return -1;
        }
        /* curpos now points to the base information, which is an OID */
        base_info = git_mwindow_open(&idx->pack->mwf, &w, curpos, GIT_OID_RAWSZ, &left);
        if (base_info == NULL) {
                giterr_set(GITERR_INDEXER, "failed to map delta information");
                return -1;
        }
        git_oid_fromraw(&base, base_info);
        git_mwindow_close(&w);
        if (has_entry(idx, &base))
                return 0;
        if (inject_object(idx, &base) < 0)
                return -1;
        stats->local_objects++;
        return 0;
}
static int resolve_deltas(git_indexer *idx, git_transfer_progress *stats)
{
        unsigned int i;
        struct delta_info *delta;
        int progressed = 0, non_null = 0, progress_cb_result;
        while (idx->deltas.length > 0) {
                progressed = 0;
                non_null = 0;
                git_vector_foreach(&idx->deltas, i, delta) {
                        git_rawobj obj = {NULL};
                        if (!delta)
                                continue;
                        non_null = 1;
                        idx->off = delta->delta_off;
                        if (git_packfile_unpack(&obj, idx->pack, &idx->off) < 0)
                                continue;
                        if (hash_and_save(idx, &obj, delta->delta_off) < 0)
                                continue;
                        git__free(obj.data);
                        stats->indexed_objects++;
                        stats->indexed_deltas++;
                        progressed = 1;
                        if ((progress_cb_result = do_progress_callback(idx, stats)) < 0)
                                return progress_cb_result;
                        /* remove from the list */
                        git_vector_set(NULL, &idx->deltas, i, NULL);
                        git__free(delta);
                }
                /* if none were actually set, we're done */
                if (!non_null)
                        break;
                if (!progressed && (fix_thin_pack(idx, stats) < 0)) {
                        return -1;
                }
        }
        return 0;
}
static int update_header_and_rehash(git_indexer *idx, git_transfer_progress *stats)
{
        void *ptr;
        size_t chunk = 1024*1024;
        git_off_t hashed = 0;
        git_mwindow *w = NULL;
        git_mwindow_file *mwf;
        unsigned int left;
        mwf = &idx->pack->mwf;
        git_hash_init(&idx->trailer);
        /* Update the header to include the numer of local objects we injected */
        idx->hdr.hdr_entries = htonl(stats->total_objects + stats->local_objects);
        if (write_at(idx, &idx->hdr, 0, sizeof(struct git_pack_header)) < 0)
                return -1;
        /*
         * We now use the same technique as before to determine the
         * hash. We keep reading up to the end and let
         * hash_partially() keep the existing trailer out of the
         * calculation.
         */
        git_mwindow_free_all(mwf);
        idx->inbuf_len = 0;
        while (hashed < mwf->size) {
                ptr = git_mwindow_open(mwf, &w, hashed, chunk, &left);
                if (ptr == NULL)
                        return -1;
                hash_partially(idx, ptr, left);
                hashed += left;
                git_mwindow_close(&w);
        }
        return 0;
}
int git_indexer_commit(git_indexer *idx, git_transfer_progress *stats)
{
        git_mwindow *w = NULL;
        unsigned int i, long_offsets = 0, left;
        int error;
        struct git_pack_idx_header hdr;
        git_buf filename = GIT_BUF_INIT;
        struct entry *entry;
        git_oid trailer_hash, file_hash;
        git_hash_ctx ctx;
        git_filebuf index_file = {0};
        void *packfile_trailer;
        if (git_hash_ctx_init(&ctx) < 0)
                return -1;
        /* Test for this before resolve_deltas(), as it plays with idx->off */
        if (idx->off < idx->pack->mwf.size - 20) {
                giterr_set(GITERR_INDEXER, "Unexpected data at the end of the pack");
                return -1;
        }
        packfile_trailer = git_mwindow_open(&idx->pack->mwf, &w, idx->pack->mwf.size - GIT_OID_RAWSZ, GIT_OID_RAWSZ, &left);
        if (packfile_trailer == NULL) {
                git_mwindow_close(&w);
                goto on_error;
        }
        /* Compare the packfile trailer as it was sent to us and what we calculated */
        git_oid_fromraw(&file_hash, packfile_trailer);
        git_mwindow_close(&w);
        git_hash_final(&trailer_hash, &idx->trailer);
        if (git_oid_cmp(&file_hash, &trailer_hash)) {
                giterr_set(GITERR_INDEXER, "packfile trailer mismatch");
                return -1;
        }
        /* Freeze the number of deltas */
        stats->total_deltas = stats->total_objects - stats->indexed_objects;
        if ((error = resolve_deltas(idx, stats)) < 0)
                return error;
        if (stats->indexed_objects != stats->total_objects) {
                giterr_set(GITERR_INDEXER, "early EOF");
                return -1;
        }
        if (stats->local_objects > 0) {
                if (update_header_and_rehash(idx, stats) < 0)
                        return -1;
                git_hash_final(&trailer_hash, &idx->trailer);
                write_at(idx, &trailer_hash, idx->pack->mwf.size - GIT_OID_RAWSZ, GIT_OID_RAWSZ);
        }
        git_vector_sort(&idx->objects);
        git_buf_sets(&filename, idx->pack->pack_name);
        git_buf_shorten(&filename, strlen("pack"));
        git_buf_puts(&filename, "idx");
        if (git_buf_oom(&filename))
                return -1;
        if (git_filebuf_open(&index_file, filename.ptr,
                GIT_FILEBUF_HASH_CONTENTS, idx->mode) < 0)
                goto on_error;
        /* Write out the header */
        hdr.idx_signature = htonl(PACK_IDX_SIGNATURE);
        hdr.idx_version = htonl(2);
        git_filebuf_write(&index_file, &hdr, sizeof(hdr));
        /* Write out the fanout table */
        for (i = 0; i < 256; ++i) {
                uint32_t n = htonl(idx->fanout[i]);
                git_filebuf_write(&index_file, &n, sizeof(n));
        }
        /* Write out the object names (SHA-1 hashes) */
        git_vector_foreach(&idx->objects, i, entry) {
                git_filebuf_write(&index_file, &entry->oid, sizeof(git_oid));
                git_hash_update(&ctx, &entry->oid, GIT_OID_RAWSZ);
        }
        git_hash_final(&idx->hash, &ctx);
        /* Write out the CRC32 values */
        git_vector_foreach(&idx->objects, i, entry) {
                git_filebuf_write(&index_file, &entry->crc, sizeof(uint32_t));
        }
        /* Write out the offsets */
        git_vector_foreach(&idx->objects, i, entry) {
                uint32_t n;
                if (entry->offset == UINT32_MAX)
                        n = htonl(0x80000000 | long_offsets++);
                else
                        n = htonl(entry->offset);
                git_filebuf_write(&index_file, &n, sizeof(uint32_t));
        }
        /* Write out the long offsets */
        git_vector_foreach(&idx->objects, i, entry) {
                uint32_t split[2];
                if (entry->offset != UINT32_MAX)
                        continue;
                split[0] = htonl(entry->offset_long >> 32);
                split[1] = htonl(entry->offset_long & 0xffffffff);
                git_filebuf_write(&index_file, &split, sizeof(uint32_t) * 2);
        }
        /* Write out the packfile trailer to the index */
        if (git_filebuf_write(&index_file, &trailer_hash, GIT_OID_RAWSZ) < 0)
                goto on_error;
        /* Write out the hash of the idx */
        if (git_filebuf_hash(&trailer_hash, &index_file) < 0)
                goto on_error;
        git_filebuf_write(&index_file, &trailer_hash, sizeof(git_oid));
        /* Figure out what the final name should be */
        if (index_path(&filename, idx, ".idx") < 0)
                goto on_error;
        /* Commit file */
        if (git_filebuf_commit_at(&index_file, filename.ptr) < 0)
                goto on_error;
        git_mwindow_free_all(&idx->pack->mwf);
        /* We need to close the descriptor here so Windows doesn't choke on commit_at */
        if (p_close(idx->pack->mwf.fd) < 0) {
                giterr_set(GITERR_OS, "failed to close packfile");
                goto on_error;
        }
        idx->pack->mwf.fd = -1;
        if (index_path(&filename, idx, ".pack") < 0)
                goto on_error;
        /* And don't forget to rename the packfile to its new place. */
        p_rename(idx->pack->pack_name, git_buf_cstr(&filename));
        git_buf_free(&filename);
        git_hash_ctx_cleanup(&ctx);
        return 0;
on_error:
        git_mwindow_free_all(&idx->pack->mwf);
        git_filebuf_cleanup(&index_file);
        git_buf_free(&filename);
        git_hash_ctx_cleanup(&ctx);
        return -1;
}
void git_indexer_free(git_indexer *idx)
{
        if (idx == NULL)
                return;
        git_vector_free_deep(&idx->objects);
        if (idx->pack && idx->pack->idx_cache) {
                struct git_pack_entry *pentry;
                kh_foreach_value(
                        idx->pack->idx_cache, pentry, { git__free(pentry); });
                git_oidmap_free(idx->pack->idx_cache);
        }
        git_vector_free_deep(&idx->deltas);
        if (!git_mutex_lock(&git__mwindow_mutex)) {
                git_packfile_free(idx->pack);
                git_mutex_unlock(&git__mwindow_mutex);
        }
        git_hash_ctx_cleanup(&idx->trailer);
        git_hash_ctx_cleanup(&idx->hash_ctx);
        git__free(idx);
}