2011-05-12 02:30:25 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2011, Google Inc.
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
|
|
|
#include "streaming.h"
|
2018-03-23 17:21:14 +00:00
|
|
|
#include "repository.h"
|
|
|
|
#include "object-store.h"
|
2018-04-12 00:21:06 +00:00
|
|
|
#include "replace-object.h"
|
2017-08-18 22:20:22 +00:00
|
|
|
#include "packfile.h"
|
2011-05-12 02:30:25 +00:00
|
|
|
|
|
|
|
enum input_source {
|
|
|
|
stream_error = -1,
|
|
|
|
incore = 0,
|
|
|
|
loose = 1,
|
|
|
|
pack_non_delta = 2
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef int (*open_istream_fn)(struct git_istream *,
|
|
|
|
struct object_info *,
|
2018-03-12 02:27:50 +00:00
|
|
|
const struct object_id *,
|
2011-05-12 02:30:25 +00:00
|
|
|
enum object_type *);
|
|
|
|
typedef int (*close_istream_fn)(struct git_istream *);
|
|
|
|
typedef ssize_t (*read_istream_fn)(struct git_istream *, char *, size_t);
|
|
|
|
|
|
|
|
struct stream_vtbl {
|
|
|
|
close_istream_fn close;
|
|
|
|
read_istream_fn read;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define open_method_decl(name) \
|
|
|
|
int open_istream_ ##name \
|
|
|
|
(struct git_istream *st, struct object_info *oi, \
|
2018-03-12 02:27:50 +00:00
|
|
|
const struct object_id *oid, \
|
2011-05-12 02:30:25 +00:00
|
|
|
enum object_type *type)
|
|
|
|
|
|
|
|
#define close_method_decl(name) \
|
|
|
|
int close_istream_ ##name \
|
|
|
|
(struct git_istream *st)
|
|
|
|
|
|
|
|
#define read_method_decl(name) \
|
|
|
|
ssize_t read_istream_ ##name \
|
|
|
|
(struct git_istream *st, char *buf, size_t sz)
|
|
|
|
|
|
|
|
/* forward declaration */
|
|
|
|
static open_method_decl(incore);
|
|
|
|
static open_method_decl(loose);
|
|
|
|
static open_method_decl(pack_non_delta);
|
2011-05-20 21:33:31 +00:00
|
|
|
static struct git_istream *attach_stream_filter(struct git_istream *st,
|
|
|
|
struct stream_filter *filter);
|
|
|
|
|
2011-05-12 02:30:25 +00:00
|
|
|
|
|
|
|
static open_istream_fn open_istream_tbl[] = {
|
|
|
|
open_istream_incore,
|
|
|
|
open_istream_loose,
|
|
|
|
open_istream_pack_non_delta,
|
|
|
|
};
|
|
|
|
|
2011-05-20 21:33:31 +00:00
|
|
|
#define FILTER_BUFFER (1024*16)
|
|
|
|
|
|
|
|
struct filtered_istream {
|
|
|
|
struct git_istream *upstream;
|
|
|
|
struct stream_filter *filter;
|
|
|
|
char ibuf[FILTER_BUFFER];
|
|
|
|
char obuf[FILTER_BUFFER];
|
|
|
|
int i_end, i_ptr;
|
|
|
|
int o_end, o_ptr;
|
2011-05-21 21:05:51 +00:00
|
|
|
int input_finished;
|
2011-05-20 21:33:31 +00:00
|
|
|
};
|
|
|
|
|
2011-05-12 02:30:25 +00:00
|
|
|
struct git_istream {
|
|
|
|
const struct stream_vtbl *vtbl;
|
|
|
|
unsigned long size; /* inflated size of full object */
|
2011-07-19 16:33:03 +00:00
|
|
|
git_zstream z;
|
2011-05-13 22:34:58 +00:00
|
|
|
enum { z_unused, z_used, z_done, z_error } z_state;
|
2011-05-12 02:30:25 +00:00
|
|
|
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
char *buf; /* from read_object() */
|
|
|
|
unsigned long read_ptr;
|
|
|
|
} incore;
|
|
|
|
|
|
|
|
struct {
|
2011-05-15 02:17:10 +00:00
|
|
|
void *mapped;
|
|
|
|
unsigned long mapsize;
|
|
|
|
char hdr[32];
|
|
|
|
int hdr_avail;
|
|
|
|
int hdr_used;
|
2011-05-12 02:30:25 +00:00
|
|
|
} loose;
|
|
|
|
|
|
|
|
struct {
|
2011-05-13 22:34:58 +00:00
|
|
|
struct packed_git *pack;
|
|
|
|
off_t pos;
|
2011-05-12 02:30:25 +00:00
|
|
|
} in_pack;
|
2011-05-20 21:33:31 +00:00
|
|
|
|
|
|
|
struct filtered_istream filtered;
|
2011-05-12 02:30:25 +00:00
|
|
|
} u;
|
|
|
|
};
|
|
|
|
|
|
|
|
int close_istream(struct git_istream *st)
|
|
|
|
{
|
2011-07-22 17:00:03 +00:00
|
|
|
int r = st->vtbl->close(st);
|
|
|
|
free(st);
|
|
|
|
return r;
|
2011-05-12 02:30:25 +00:00
|
|
|
}
|
|
|
|
|
2012-05-03 01:51:00 +00:00
|
|
|
ssize_t read_istream(struct git_istream *st, void *buf, size_t sz)
|
2011-05-12 02:30:25 +00:00
|
|
|
{
|
|
|
|
return st->vtbl->read(st, buf, sz);
|
|
|
|
}
|
|
|
|
|
2018-03-12 02:27:54 +00:00
|
|
|
static enum input_source istream_source(const struct object_id *oid,
|
2011-05-12 02:30:25 +00:00
|
|
|
enum object_type *type,
|
|
|
|
struct object_info *oi)
|
|
|
|
{
|
|
|
|
unsigned long size;
|
|
|
|
int status;
|
|
|
|
|
2013-07-12 06:34:57 +00:00
|
|
|
oi->typep = type;
|
2011-05-12 02:30:25 +00:00
|
|
|
oi->sizep = &size;
|
2018-03-12 02:27:54 +00:00
|
|
|
status = oid_object_info_extended(oid, oi, 0);
|
2011-05-12 02:30:25 +00:00
|
|
|
if (status < 0)
|
|
|
|
return stream_error;
|
|
|
|
|
|
|
|
switch (oi->whence) {
|
|
|
|
case OI_LOOSE:
|
|
|
|
return loose;
|
|
|
|
case OI_PACKED:
|
2012-05-16 12:02:09 +00:00
|
|
|
if (!oi->u.packed.is_delta && big_file_threshold < size)
|
2011-05-12 02:30:25 +00:00
|
|
|
return pack_non_delta;
|
|
|
|
/* fallthru */
|
|
|
|
default:
|
|
|
|
return incore;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-12 02:27:40 +00:00
|
|
|
struct git_istream *open_istream(const struct object_id *oid,
|
2011-05-12 02:30:25 +00:00
|
|
|
enum object_type *type,
|
2011-05-20 21:33:31 +00:00
|
|
|
unsigned long *size,
|
|
|
|
struct stream_filter *filter)
|
2011-05-12 02:30:25 +00:00
|
|
|
{
|
|
|
|
struct git_istream *st;
|
provide an initializer for "struct object_info"
An all-zero initializer is fine for this struct, but because
the first element is a pointer, call sites need to know to
use "NULL" instead of "0". Otherwise some static checkers
like "sparse" will complain; see d099b71 (Fix some sparse
warnings, 2013-07-18) for example. So let's provide an
initializer to make this easier to get right.
But let's also comment that memset() to zero is explicitly
OK[1]. One of the callers embeds object_info in another
struct which is initialized via memset (expand_data in
builtin/cat-file.c). Since our subset of C doesn't allow
assignment from a compound literal, handling this in any
other way is awkward, so we'd like to keep the ability to
initialize by memset(). By documenting this property, it
should make anybody who wants to change the initializer
think twice before doing so.
There's one other caller of interest. In parse_sha1_header(),
we did not initialize the struct fully in the first place.
This turned out not to be a bug because the sub-function it
calls does not look at any other fields except the ones we
did initialize. But that assumption might not hold in the
future, so it's a dangerous construct. This patch switches
it to initializing the whole struct, which protects us
against unexpected reads of the other fields.
[1] Obviously using memset() to initialize a pointer
violates the C standard, but we long ago decided that it
was an acceptable tradeoff in the real world.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-08-11 09:24:35 +00:00
|
|
|
struct object_info oi = OBJECT_INFO_INIT;
|
2018-04-12 00:21:13 +00:00
|
|
|
const struct object_id *real = lookup_replace_object(the_repository, oid);
|
2011-05-12 02:30:25 +00:00
|
|
|
enum input_source src = istream_source(real, type, &oi);
|
|
|
|
|
|
|
|
if (src < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
st = xmalloc(sizeof(*st));
|
2018-03-12 02:27:54 +00:00
|
|
|
if (open_istream_tbl[src](st, &oi, real, type)) {
|
|
|
|
if (open_istream_incore(st, &oi, real, type)) {
|
2011-05-12 02:30:25 +00:00
|
|
|
free(st);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2013-07-23 13:16:04 +00:00
|
|
|
if (filter) {
|
2011-05-20 21:33:31 +00:00
|
|
|
/* Add "&& !is_null_stream_filter(filter)" for performance */
|
|
|
|
struct git_istream *nst = attach_stream_filter(st, filter);
|
2014-02-19 00:00:53 +00:00
|
|
|
if (!nst) {
|
2011-05-20 21:33:31 +00:00
|
|
|
close_istream(st);
|
2014-02-19 00:00:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2011-05-20 21:33:31 +00:00
|
|
|
st = nst;
|
|
|
|
}
|
|
|
|
|
2011-05-12 02:30:25 +00:00
|
|
|
*size = st->size;
|
|
|
|
return st;
|
|
|
|
}
|
|
|
|
|
2011-05-13 22:34:58 +00:00
|
|
|
|
|
|
|
/*****************************************************************
|
|
|
|
*
|
|
|
|
* Common helpers
|
|
|
|
*
|
|
|
|
*****************************************************************/
|
|
|
|
|
|
|
|
static void close_deflated_stream(struct git_istream *st)
|
|
|
|
{
|
|
|
|
if (st->z_state == z_used)
|
|
|
|
git_inflate_end(&st->z);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-20 21:33:31 +00:00
|
|
|
/*****************************************************************
|
|
|
|
*
|
|
|
|
* Filtered stream
|
|
|
|
*
|
|
|
|
*****************************************************************/
|
|
|
|
|
|
|
|
static close_method_decl(filtered)
|
|
|
|
{
|
|
|
|
free_stream_filter(st->u.filtered.filter);
|
|
|
|
return close_istream(st->u.filtered.upstream);
|
|
|
|
}
|
|
|
|
|
|
|
|
static read_method_decl(filtered)
|
|
|
|
{
|
|
|
|
struct filtered_istream *fs = &(st->u.filtered);
|
|
|
|
size_t filled = 0;
|
|
|
|
|
|
|
|
while (sz) {
|
|
|
|
/* do we already have filtered output? */
|
|
|
|
if (fs->o_ptr < fs->o_end) {
|
|
|
|
size_t to_move = fs->o_end - fs->o_ptr;
|
|
|
|
if (sz < to_move)
|
|
|
|
to_move = sz;
|
|
|
|
memcpy(buf + filled, fs->obuf + fs->o_ptr, to_move);
|
|
|
|
fs->o_ptr += to_move;
|
|
|
|
sz -= to_move;
|
|
|
|
filled += to_move;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
fs->o_end = fs->o_ptr = 0;
|
|
|
|
|
|
|
|
/* do we have anything to feed the filter with? */
|
|
|
|
if (fs->i_ptr < fs->i_end) {
|
|
|
|
size_t to_feed = fs->i_end - fs->i_ptr;
|
|
|
|
size_t to_receive = FILTER_BUFFER;
|
|
|
|
if (stream_filter(fs->filter,
|
|
|
|
fs->ibuf + fs->i_ptr, &to_feed,
|
|
|
|
fs->obuf, &to_receive))
|
|
|
|
return -1;
|
|
|
|
fs->i_ptr = fs->i_end - to_feed;
|
|
|
|
fs->o_end = FILTER_BUFFER - to_receive;
|
|
|
|
continue;
|
|
|
|
}
|
2011-05-21 21:05:51 +00:00
|
|
|
|
|
|
|
/* tell the filter to drain upon no more input */
|
|
|
|
if (fs->input_finished) {
|
|
|
|
size_t to_receive = FILTER_BUFFER;
|
|
|
|
if (stream_filter(fs->filter,
|
|
|
|
NULL, NULL,
|
|
|
|
fs->obuf, &to_receive))
|
|
|
|
return -1;
|
|
|
|
fs->o_end = FILTER_BUFFER - to_receive;
|
|
|
|
if (!fs->o_end)
|
|
|
|
break;
|
|
|
|
continue;
|
|
|
|
}
|
2011-05-20 21:33:31 +00:00
|
|
|
fs->i_end = fs->i_ptr = 0;
|
|
|
|
|
|
|
|
/* refill the input from the upstream */
|
2011-05-21 21:05:51 +00:00
|
|
|
if (!fs->input_finished) {
|
|
|
|
fs->i_end = read_istream(fs->upstream, fs->ibuf, FILTER_BUFFER);
|
|
|
|
if (fs->i_end < 0)
|
2013-03-25 20:18:16 +00:00
|
|
|
return -1;
|
2011-05-21 21:05:51 +00:00
|
|
|
if (fs->i_end)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
fs->input_finished = 1;
|
2011-05-20 21:33:31 +00:00
|
|
|
}
|
|
|
|
return filled;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct stream_vtbl filtered_vtbl = {
|
|
|
|
close_istream_filtered,
|
|
|
|
read_istream_filtered,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct git_istream *attach_stream_filter(struct git_istream *st,
|
|
|
|
struct stream_filter *filter)
|
|
|
|
{
|
|
|
|
struct git_istream *ifs = xmalloc(sizeof(*ifs));
|
|
|
|
struct filtered_istream *fs = &(ifs->u.filtered);
|
|
|
|
|
|
|
|
ifs->vtbl = &filtered_vtbl;
|
|
|
|
fs->upstream = st;
|
|
|
|
fs->filter = filter;
|
|
|
|
fs->i_end = fs->i_ptr = 0;
|
|
|
|
fs->o_end = fs->o_ptr = 0;
|
2011-05-21 21:05:51 +00:00
|
|
|
fs->input_finished = 0;
|
2011-05-20 21:33:31 +00:00
|
|
|
ifs->size = -1; /* unknown */
|
|
|
|
return ifs;
|
|
|
|
}
|
|
|
|
|
2011-05-12 02:30:25 +00:00
|
|
|
/*****************************************************************
|
|
|
|
*
|
|
|
|
* Loose object stream
|
|
|
|
*
|
|
|
|
*****************************************************************/
|
|
|
|
|
2011-05-15 02:17:10 +00:00
|
|
|
static read_method_decl(loose)
|
|
|
|
{
|
|
|
|
size_t total_read = 0;
|
|
|
|
|
|
|
|
switch (st->z_state) {
|
|
|
|
case z_done:
|
|
|
|
return 0;
|
|
|
|
case z_error:
|
|
|
|
return -1;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (st->u.loose.hdr_used < st->u.loose.hdr_avail) {
|
|
|
|
size_t to_copy = st->u.loose.hdr_avail - st->u.loose.hdr_used;
|
|
|
|
if (sz < to_copy)
|
|
|
|
to_copy = sz;
|
|
|
|
memcpy(buf, st->u.loose.hdr + st->u.loose.hdr_used, to_copy);
|
|
|
|
st->u.loose.hdr_used += to_copy;
|
|
|
|
total_read += to_copy;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (total_read < sz) {
|
|
|
|
int status;
|
|
|
|
|
|
|
|
st->z.next_out = (unsigned char *)buf + total_read;
|
|
|
|
st->z.avail_out = sz - total_read;
|
|
|
|
status = git_inflate(&st->z, Z_FINISH);
|
|
|
|
|
|
|
|
total_read = st->z.next_out - (unsigned char *)buf;
|
|
|
|
|
|
|
|
if (status == Z_STREAM_END) {
|
|
|
|
git_inflate_end(&st->z);
|
|
|
|
st->z_state = z_done;
|
|
|
|
break;
|
|
|
|
}
|
avoid infinite loop in read_istream_loose
The read_istream_loose function loops on inflating a chunk of data
from an mmap'd loose object. We end the loop when we run out
of space in our output buffer, or if we see a zlib error.
We need to treat Z_BUF_ERROR specially, though, as it is not
fatal; it is just zlib's way of telling us that we need to
either feed it more input or give it more output space. It
is perfectly normal for us to hit this when we are at the
end of our buffer.
However, we may also get Z_BUF_ERROR because we have run out
of input. In a well-formed object, this should not happen,
because we have fed the whole mmap'd contents to zlib. But
if the object is truncated or corrupt, we will loop forever,
never giving zlib any more data, but continuing to ask it to
inflate.
We can fix this by considering it an error when zlib returns
Z_BUF_ERROR but we still have output space left (which means
it must want more input, which we know is a truncation
error). It would not be sufficient to just check whether
zlib had consumed all the input at the start of the loop, as
it might still want to generate output from what is in its
internal state.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-25 20:21:14 +00:00
|
|
|
if (status != Z_OK && (status != Z_BUF_ERROR || total_read < sz)) {
|
2011-05-15 02:17:10 +00:00
|
|
|
git_inflate_end(&st->z);
|
|
|
|
st->z_state = z_error;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return total_read;
|
|
|
|
}
|
|
|
|
|
|
|
|
static close_method_decl(loose)
|
|
|
|
{
|
|
|
|
close_deflated_stream(st);
|
|
|
|
munmap(st->u.loose.mapped, st->u.loose.mapsize);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct stream_vtbl loose_vtbl = {
|
|
|
|
close_istream_loose,
|
|
|
|
read_istream_loose,
|
|
|
|
};
|
|
|
|
|
2011-05-12 02:30:25 +00:00
|
|
|
static open_method_decl(loose)
|
|
|
|
{
|
2018-03-23 17:21:14 +00:00
|
|
|
st->u.loose.mapped = map_sha1_file(the_repository,
|
2018-04-11 04:09:55 +00:00
|
|
|
oid->hash, &st->u.loose.mapsize);
|
2011-05-15 02:17:10 +00:00
|
|
|
if (!st->u.loose.mapped)
|
|
|
|
return -1;
|
2016-09-26 16:23:41 +00:00
|
|
|
if ((unpack_sha1_header(&st->z,
|
|
|
|
st->u.loose.mapped,
|
|
|
|
st->u.loose.mapsize,
|
|
|
|
st->u.loose.hdr,
|
|
|
|
sizeof(st->u.loose.hdr)) < 0) ||
|
|
|
|
(parse_sha1_header(st->u.loose.hdr, &st->size) < 0)) {
|
2011-05-15 02:17:10 +00:00
|
|
|
git_inflate_end(&st->z);
|
|
|
|
munmap(st->u.loose.mapped, st->u.loose.mapsize);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
st->u.loose.hdr_used = strlen(st->u.loose.hdr) + 1;
|
|
|
|
st->u.loose.hdr_avail = st->z.total_out;
|
|
|
|
st->z_state = z_used;
|
|
|
|
|
|
|
|
st->vtbl = &loose_vtbl;
|
|
|
|
return 0;
|
2011-05-12 02:30:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************
|
|
|
|
*
|
|
|
|
* Non-delta packed object stream
|
|
|
|
*
|
|
|
|
*****************************************************************/
|
|
|
|
|
2011-05-13 22:34:58 +00:00
|
|
|
static read_method_decl(pack_non_delta)
|
|
|
|
{
|
|
|
|
size_t total_read = 0;
|
|
|
|
|
|
|
|
switch (st->z_state) {
|
|
|
|
case z_unused:
|
|
|
|
memset(&st->z, 0, sizeof(st->z));
|
|
|
|
git_inflate_init(&st->z);
|
|
|
|
st->z_state = z_used;
|
|
|
|
break;
|
|
|
|
case z_done:
|
|
|
|
return 0;
|
|
|
|
case z_error:
|
|
|
|
return -1;
|
|
|
|
case z_used:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (total_read < sz) {
|
|
|
|
int status;
|
|
|
|
struct pack_window *window = NULL;
|
|
|
|
unsigned char *mapped;
|
|
|
|
|
|
|
|
mapped = use_pack(st->u.in_pack.pack, &window,
|
|
|
|
st->u.in_pack.pos, &st->z.avail_in);
|
|
|
|
|
|
|
|
st->z.next_out = (unsigned char *)buf + total_read;
|
|
|
|
st->z.avail_out = sz - total_read;
|
|
|
|
st->z.next_in = mapped;
|
|
|
|
status = git_inflate(&st->z, Z_FINISH);
|
|
|
|
|
|
|
|
st->u.in_pack.pos += st->z.next_in - mapped;
|
|
|
|
total_read = st->z.next_out - (unsigned char *)buf;
|
|
|
|
unuse_pack(&window);
|
|
|
|
|
|
|
|
if (status == Z_STREAM_END) {
|
|
|
|
git_inflate_end(&st->z);
|
|
|
|
st->z_state = z_done;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (status != Z_OK && status != Z_BUF_ERROR) {
|
|
|
|
git_inflate_end(&st->z);
|
|
|
|
st->z_state = z_error;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return total_read;
|
|
|
|
}
|
|
|
|
|
|
|
|
static close_method_decl(pack_non_delta)
|
|
|
|
{
|
|
|
|
close_deflated_stream(st);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct stream_vtbl pack_non_delta_vtbl = {
|
|
|
|
close_istream_pack_non_delta,
|
|
|
|
read_istream_pack_non_delta,
|
|
|
|
};
|
|
|
|
|
2011-05-12 02:30:25 +00:00
|
|
|
static open_method_decl(pack_non_delta)
|
|
|
|
{
|
2011-05-13 22:34:58 +00:00
|
|
|
struct pack_window *window;
|
|
|
|
enum object_type in_pack_type;
|
|
|
|
|
|
|
|
st->u.in_pack.pack = oi->u.packed.pack;
|
|
|
|
st->u.in_pack.pos = oi->u.packed.offset;
|
|
|
|
window = NULL;
|
|
|
|
|
|
|
|
in_pack_type = unpack_object_header(st->u.in_pack.pack,
|
|
|
|
&window,
|
|
|
|
&st->u.in_pack.pos,
|
|
|
|
&st->size);
|
|
|
|
unuse_pack(&window);
|
|
|
|
switch (in_pack_type) {
|
|
|
|
default:
|
|
|
|
return -1; /* we do not do deltas for now */
|
|
|
|
case OBJ_COMMIT:
|
|
|
|
case OBJ_TREE:
|
|
|
|
case OBJ_BLOB:
|
|
|
|
case OBJ_TAG:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
st->z_state = z_unused;
|
|
|
|
st->vtbl = &pack_non_delta_vtbl;
|
|
|
|
return 0;
|
2011-05-12 02:30:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************
|
|
|
|
*
|
|
|
|
* In-core stream
|
|
|
|
*
|
|
|
|
*****************************************************************/
|
|
|
|
|
|
|
|
static close_method_decl(incore)
|
|
|
|
{
|
|
|
|
free(st->u.incore.buf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static read_method_decl(incore)
|
|
|
|
{
|
|
|
|
size_t read_size = sz;
|
|
|
|
size_t remainder = st->size - st->u.incore.read_ptr;
|
|
|
|
|
|
|
|
if (remainder <= read_size)
|
|
|
|
read_size = remainder;
|
|
|
|
if (read_size) {
|
|
|
|
memcpy(buf, st->u.incore.buf + st->u.incore.read_ptr, read_size);
|
|
|
|
st->u.incore.read_ptr += read_size;
|
|
|
|
}
|
|
|
|
return read_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct stream_vtbl incore_vtbl = {
|
|
|
|
close_istream_incore,
|
|
|
|
read_istream_incore,
|
|
|
|
};
|
|
|
|
|
|
|
|
static open_method_decl(incore)
|
|
|
|
{
|
sha1_file: convert read_sha1_file to struct object_id
Convert read_sha1_file to take a pointer to struct object_id and rename
it read_object_file. Do the same for read_sha1_file_extended.
Convert one use in grep.c to use the new function without any other code
change, since the pointer being passed is a void pointer that is already
initialized with a pointer to struct object_id. Update the declaration
and definitions of the modified functions, and apply the following
semantic patch to convert the remaining callers:
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1.hash, E2, E3)
+ read_object_file(&E1, E2, E3)
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1->hash, E2, E3)
+ read_object_file(E1, E2, E3)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1.hash, E2, E3, E4)
+ read_object_file_extended(&E1, E2, E3, E4)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1->hash, E2, E3, E4)
+ read_object_file_extended(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:53 +00:00
|
|
|
st->u.incore.buf = read_object_file_extended(oid, type, &st->size, 0);
|
2011-05-12 02:30:25 +00:00
|
|
|
st->u.incore.read_ptr = 0;
|
|
|
|
st->vtbl = &incore_vtbl;
|
|
|
|
|
|
|
|
return st->u.incore.buf ? 0 : -1;
|
|
|
|
}
|
2012-03-07 10:54:15 +00:00
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
* Users of streaming interface
|
|
|
|
****************************************************************/
|
|
|
|
|
2016-09-05 20:07:59 +00:00
|
|
|
int stream_blob_to_fd(int fd, const struct object_id *oid, struct stream_filter *filter,
|
2012-03-07 10:54:15 +00:00
|
|
|
int can_seek)
|
|
|
|
{
|
|
|
|
struct git_istream *st;
|
|
|
|
enum object_type type;
|
|
|
|
unsigned long sz;
|
|
|
|
ssize_t kept = 0;
|
|
|
|
int result = -1;
|
|
|
|
|
2018-03-12 02:27:40 +00:00
|
|
|
st = open_istream(oid, &type, &sz, filter);
|
2015-03-31 01:22:11 +00:00
|
|
|
if (!st) {
|
|
|
|
if (filter)
|
|
|
|
free_stream_filter(filter);
|
2012-03-07 10:54:15 +00:00
|
|
|
return result;
|
2015-03-31 01:22:11 +00:00
|
|
|
}
|
2012-03-07 10:54:15 +00:00
|
|
|
if (type != OBJ_BLOB)
|
|
|
|
goto close_and_exit;
|
|
|
|
for (;;) {
|
|
|
|
char buf[1024 * 16];
|
|
|
|
ssize_t wrote, holeto;
|
|
|
|
ssize_t readlen = read_istream(st, buf, sizeof(buf));
|
|
|
|
|
2013-03-25 20:16:50 +00:00
|
|
|
if (readlen < 0)
|
|
|
|
goto close_and_exit;
|
2012-03-07 10:54:15 +00:00
|
|
|
if (!readlen)
|
|
|
|
break;
|
|
|
|
if (can_seek && sizeof(buf) == readlen) {
|
|
|
|
for (holeto = 0; holeto < readlen; holeto++)
|
|
|
|
if (buf[holeto])
|
|
|
|
break;
|
|
|
|
if (readlen == holeto) {
|
|
|
|
kept += holeto;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (kept && lseek(fd, kept, SEEK_CUR) == (off_t) -1)
|
|
|
|
goto close_and_exit;
|
|
|
|
else
|
|
|
|
kept = 0;
|
|
|
|
wrote = write_in_full(fd, buf, readlen);
|
|
|
|
|
2017-09-13 17:16:28 +00:00
|
|
|
if (wrote < 0)
|
2012-03-07 10:54:15 +00:00
|
|
|
goto close_and_exit;
|
|
|
|
}
|
|
|
|
if (kept && (lseek(fd, kept - 1, SEEK_CUR) == (off_t) -1 ||
|
2014-01-17 14:17:09 +00:00
|
|
|
xwrite(fd, "", 1) != 1))
|
2012-03-07 10:54:15 +00:00
|
|
|
goto close_and_exit;
|
|
|
|
result = 0;
|
|
|
|
|
|
|
|
close_and_exit:
|
|
|
|
close_istream(st);
|
|
|
|
return result;
|
|
|
|
}
|