hdrlen = format_object_header((char *)hdr, sizeof(hdr), type,

dat->len);

the_hash_algo->init_fn(&c);

if (oidout)

oidcpy(oidout, &oid);

hdrlen = format_object_header((char *)out_buf, out_sz, OBJ_BLOB, len);

the_hash_algo->init_fn(&c);

crc32_begin(pack_file);

if (!n && feof(stdin))

die("EOF in data (%" PRIuMAX " bytes remaining)", len);

s.next_in = in_buf;

s.avail_in = n;

len -= n;

}

}

git_deflate_end(&s);

if (oidout)

oidcpy(oidout, &oid);

if (input_offset) {

if (output_fd >= 0)

write_or_die(output_fd, input_buffer, input_offset);

memmove(input_buffer, input_buffer + input_offset, input_len);

input_offset = 0;

}

if (!is_delta_type(type)) {

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

the_hash_algo->init_fn(&c);

} else

oid = NULL;

if (type == OBJ_BLOB && size > big_file_threshold)

status = git_inflate(&stream, 0);

use(input_len - stream.avail_in);

if (oid)

if (buf == fixed_buf) {

stream.next_out = buf;

stream.avail_out = sizeof(fixed_buf);

bad_object(offset, _("inflate returned %d"), status);

git_inflate_end(&stream);

if (oid)

return buf == fixed_buf ? NULL : buf;

}

/* Check pack integrity */

flush();

if (!hasheq(fill(the_hash_algo->rawsz), hash, the_repository->hash_algo))

die(_("pack is corrupted (SHA1 mismatch)"));

use(the_hash_algo->rawsz);

!skip_prefix(line, "From ", &p) &&

starts_with(line, "\\ ") && 12 < strlen(line)) {

if (verbatim)

continue;

}

starts_with(line, "Binary files")) {

diff_is_binary = 1;

before = 0;

if (stable)

flush_one_hunk(result, &ctx);

continue;

/* Add line to hash algo (possibly removing whitespace) */

len = verbatim ? strlen(line) : remove_space(line);

patchlen += len;

}

if (!found_next)

memset(key, '\0', GIT_MAX_BLKSZ);

if (the_hash_algo->blksz < key_len) {

the_hash_algo->init_fn(&ctx);

} else {

memcpy(key, key_in, key_len);

}

/* RFC 2104 2. (3) & (4) */

the_hash_algo->init_fn(&ctx);

/* RFC 2104 2. (6) & (7) */

the_hash_algo->init_fn(&ctx);

}

static char *prepare_push_cert_nonce(const char *path, timestamp_t stamp)

if (min > sizeof(buffer))

die("cannot fill %d bytes", min);

if (offset) {

memmove(buffer, buffer + offset, len);

offset = 0;

}

}

the_hash_algo->init_fn(&ctx);

unpack_all();

if (strict) {

write_rest();

if (fsck_finish(&fsck_options))

if (rsize < hsize)

hsize = rsize;

if (hsize)

*already_hashed_to = offset;

}

s.next_in = ibuf;

header_len = format_object_header((char *)obuf, sizeof(obuf),

OBJ_BLOB, size);

the_hash_algo->init_fn(&ctx);

/* Note: idx is non-NULL when we are writing */

if ((flags & HASH_WRITE_OBJECT) != 0) {

if (lseek(fd, seekback, SEEK_SET) == (off_t) -1)

return error("cannot seek back");

}

if (!idx)

return 0;

if (offset) {

if (!f->skip_hash)

flush(f, f->buffer, offset);

f->offset = 0;

}

if (f->skip_hash)

hashclr(f->buffer, f->algop);

else

if (result)

hashcpy(result, f->buffer, f->algop);

* f->offset is necessarily zero.

*/

if (!f->skip_hash)

flush(f, buf, nr);

} else {

/*

{

hashflush(f);

checkpoint->offset = f->total;

}

int hashfile_truncate(struct hashfile *f, struct hashfile_checkpoint *checkpoint)

lseek(f->fd, offset, SEEK_SET) != offset)

return -1;

f->total = offset;

f->offset = 0; /* hashflush() was called in checkpoint */

return 0;

}

return 0; /* say "too short"? */

algop->init_fn(&ctx);

return hasheq(got, data + data_len, algop);

}

unsigned short carry = 0;

int i;

the_hash_algo->init_fn(ctx);

/* 20-byte sum, with carry */

for (i = 0; i < the_hash_algo->rawsz; ++i) {

return 0;

new_len = remove_space(line, len);

data->patchlen += new_len;

return 0;

}

static void patch_id_add_string(struct git_hash_ctx *ctx, const char *str)

{

}

static void patch_id_add_mode(struct git_hash_ctx *ctx, unsigned mode)

/* large enough for 2^32 in octal */

char buf[12];

int len = xsnprintf(buf, sizeof(buf), "%06o", mode);

}

/* returns 0 upon success, and writes result into oid */

len2 = remove_space(p->two->path, strlen(p->two->path));

patch_id_add_string(&ctx, "diff--git");

patch_id_add_string(&ctx, "a/");

patch_id_add_string(&ctx, "b/");

if (p->one->mode == 0) {

patch_id_add_string(&ctx, "newfilemode");

/* don't do anything since we're only populating header info */

} else if (diff_filespec_is_binary(options->repo, p->one) ||

diff_filespec_is_binary(options->repo, p->two)) {

the_hash_algo->hexsz);

the_hash_algo->hexsz);

} else {

if (p->one->mode == 0) {

patch_id_add_string(&ctx, "---/dev/null");

patch_id_add_string(&ctx, "+++b/");

} else if (p->two->mode == 0) {

patch_id_add_string(&ctx, "---a/");

patch_id_add_string(&ctx, "+++/dev/null");

} else {

patch_id_add_string(&ctx, "---a/");

patch_id_add_string(&ctx, "+++b/");

}

if (fill_mmfile(options->repo, &mf1, p->one) < 0 ||

lock->token = xstrdup(ctx->cdata);

the_hash_algo->init_fn(&hash_ctx);

lock->tmpfile_suffix[0] = '_';

memcpy(lock->tmpfile_suffix + 1, hash_to_hex(lock_token_hash), the_hash_algo->hexsz);

freq->stream.next_out = expn;

freq->stream.avail_out = sizeof(expn);

freq->zret = git_inflate(&freq->stream, Z_SYNC_FLUSH);

} while (freq->stream.avail_in && freq->zret == Z_OK);

return nmemb;

}

return -1;

}

if (freq->zret != Z_STREAM_END) {

unlink_or_warn(freq->tmpfile.buf);

return -1;

/* Sha1.. */

r->hash_algo->init_fn(&c);

for (;;) {

char buf[1024 * 16];

ssize_t readlen = read_istream(st, buf, sizeof(buf));

}

if (!readlen)

break;

}

close_istream(st);

return !oideq(oid, &real_oid) ? -1 : 0;

}

char *hdr, int *hdrlen)

{

algo->init_fn(c);

}

static void write_object_file_prepare(const struct git_hash_algo *algo,

stream->avail_in = hdrlen;

while (git_deflate(stream, 0) == Z_OK)

; /* nothing */

if (compat && compat_c)

return fd;

}

const size_t compressed_len)

{

struct repository *repo = the_repository;

const struct git_hash_algo *compat = repo->compat_hash_algo;

int ret;

ret = git_deflate(stream, flush ? Z_FINISH : 0);

if (compat && compat_c)

if (write_in_full(fd, compressed, stream->next_out - compressed) < 0)

die_errno(_("unable to write loose object file"));

stream->next_out = compressed;

struct object_id *compat_oid)

{

struct repository *repo = the_repository;

const struct git_hash_algo *compat = repo->compat_hash_algo;

int ret;

ret = git_deflate_end_gently(stream);

if (ret != Z_OK)

return ret;

if (compat && compat_c)

return Z_OK;

}

int status = Z_OK;

the_hash_algo->init_fn(&c);

/*

* We already read some bytes into hdr, but the ones up to the NUL

if (size - total_read < stream->avail_out)

stream->avail_out = size - total_read;

status = git_inflate(stream, Z_FINISH);

total_read += stream->next_out - buf;

}

git_inflate_end(stream);

return -1;

}

if (!oideq(expected_oid, &real_oid)) {

error(_("hash mismatch for %s (expected %s)"), path,

oid_to_hex(expected_oid));

pack_sig_ofs = p->pack_size - r->hash_algo->rawsz;

if (offset > pack_sig_ofs)

remaining -= (unsigned int)(offset - pack_sig_ofs);

} while (offset < pack_sig_ofs);

pack_sig = use_pack(p, w_curs, pack_sig_ofs, NULL);

if (!hasheq(hash, pack_sig, the_repository->hash_algo))

err = error("%s pack checksum mismatch",

pack_name);

if (lseek(pack_fd, 0, SEEK_SET) != 0)

die_errno("Failed seeking to start of '%s'", pack_name);

hdr.hdr_entries = htonl(object_count);

write_or_die(pack_fd, &hdr, sizeof(hdr));

partial_pack_offset -= sizeof(hdr);

break;

if (n < 0)

die_errno("Failed to checksum '%s'", pack_name);

aligned_sz -= n;

if (!aligned_sz)

if (!partial_pack_hash)

continue;

partial_pack_offset -= n;

if (partial_pack_offset == 0) {

unsigned char hash[GIT_MAX_RAWSZ];

if (!hasheq(hash, partial_pack_hash,

the_repository->hash_algo))

die("Unexpected checksum for %s "

free(buf);

if (partial_pack_hash)

write_or_die(pack_fd, new_pack_hash, the_hash_algo->rawsz);

fsync_component_or_die(FSYNC_COMPONENT_PACK, pack_fd, pack_name);

}

return 0;

the_hash_algo->init_fn(&c);

if (!hasheq(hash, start, the_repository->hash_algo))

return error(_("bad index file sha1 signature"));

return 0;

if (eoie_f) {

ext = htonl(ext);

sz = htonl(sz);

}

return 0;

}

if (src_offset + 8 + extsize < src_offset)

return 0;

src_offset += 8;

src_offset += extsize;

}

if (!hasheq(hash, (const unsigned char *)index, the_repository->hash_algo))

return 0;

strbuf_add(sb, &buffer, sizeof(uint32_t));

/* hash */

strbuf_add(sb, hash, the_hash_algo->rawsz);

}

strbuf_addbuf(out, &two);

rerere_strbuf_putconflict(out, '>', marker_size);

if (ctx) {

}

break;

} else if (hunk == RR_SIDE_1)

strbuf_release(&out);

if (hash)

return has_conflicts;

}

static inline void compute_hash(const struct git_hash_algo *algo, struct git_hash_ctx *ctx, uint8_t *final, const void *p, size_t len)

{

algo->init_fn(ctx);

}

int cmd__hash_speed(int ac, const char **av)

}

if (this_sz == 0)

break;

}

if (binary)

fwrite(hash, 1, algop->rawsz, stdout);

const struct git_hash_algo *algop = &hash_algos[i];

algop->init_fn(&ctx);

cl_assert_equal_s(hash_to_hex_algop(hash,algop), expected_hashes[i - 1]);

}

strbuf_add(&tr2sid_buf, "Localhost", 9);

else {

algo->init_fn(&ctx);

hash_to_hex_algop_r(hex, hash, algo);

strbuf_addch(&tr2sid_buf, 'H');

strbuf_add(&tr2sid_buf, hex, 8);