* [PATCH 1/4] unpack-objects: use size_t for object sizes
2026-10-31 11:39 [PATCH 0/4] use size_t when receiving and verifying packs Elia Pinto
@ 2026-10-31 11:39 ` Elia Pinto
2026-10-31 11:39 ` [PATCH 2/4] index-pack: use size_t in write_compressed() Elia Pinto
` (3 subsequent siblings)
4 siblings, 0 replies; 14+ messages in thread
From: Elia Pinto @ 2026-10-31 11:39 UTC (permalink / raw)
To: git
Cc: Johannes Schindelin, Elia Pinto, Patrick Steinhardt,
Justin Tobler, Junio C Hamano, Han Xin, Han Xin,
Ævar Arnfjörð Bjarmason
builtin/unpack-objects.c uses "unsigned long" to track object sizes
throughout the file, while sizes read from packs are handled as size_t.
On platforms where "long" is 32 bits, this truncates the size for
objects of 4GiB or more.
When handling large objects on those platforms, unpack-objects fails
rather than corrupting data. For instance, streaming large blobs
(exceeding core.bigFileThreshold) passes a truncated size to
stream_blob(), causing the stream write to fail with an error.
Use size_t across the board in builtin/unpack-objects.c and remove the
now-unnecessary size cast in unpack_delta_entry(). Downstream consumers
like odb_write_object() and fsck_object() are updated separately.
Triggering this requires processing 4GiB or more of input on a platform
where "long" is 32 bits, so no test is added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
---
builtin/unpack-objects.c | 36 +++++++++++++++++-------------------
1 file changed, 17 insertions(+), 19 deletions(-)
diff --git a/builtin/unpack-objects.c b/builtin/unpack-objects.c
index 351948724a..6c830a606f 100644
--- a/builtin/unpack-objects.c
+++ b/builtin/unpack-objects.c
@@ -40,7 +40,7 @@ static struct progress *progress;
*/
struct obj_buffer {
char *buffer;
- unsigned long size;
+ size_t size;
};
static struct decoration obj_decorate;
@@ -50,7 +50,7 @@ static struct obj_buffer *lookup_object_buffer(struct object *base)
return lookup_decoration(&obj_decorate, base);
}
-static void add_object_buffer(struct object *object, char *buffer, unsigned long size)
+static void add_object_buffer(struct object *object, char *buffer, size_t size)
{
struct obj_buffer *obj;
CALLOC_ARRAY(obj, 1);
@@ -114,10 +114,10 @@ static void use(int bytes)
* allocated buffer which is reused to hold temporary zstream output
* and return NULL instead of returning garbage data.
*/
-static void *get_data(unsigned long size)
+static void *get_data(size_t size)
{
git_zstream stream;
- unsigned long bufsize = dry_run && size > 8192 ? 8192 : size;
+ size_t bufsize = dry_run && size > 8192 ? 8192 : size;
void *buf = xmallocz(bufsize);
memset(&stream, 0, sizeof(stream));
@@ -161,7 +161,7 @@ struct delta_info {
struct object_id base_oid;
unsigned nr;
off_t base_offset;
- unsigned long size;
+ size_t size;
void *delta;
struct delta_info *next;
};
@@ -170,7 +170,7 @@ static struct delta_info *delta_list;
static void add_delta_to_list(unsigned nr, const struct object_id *base_oid,
off_t base_offset,
- void *delta, unsigned long size)
+ void *delta, size_t size)
{
struct delta_info *info = xmalloc(sizeof(*info));
@@ -261,7 +261,7 @@ static void write_rest(void)
}
static void added_object(unsigned nr, enum object_type type,
- void *data, unsigned long size);
+ void *data, size_t size);
/*
* Write out nr-th object from the list, now we know the contents
@@ -269,7 +269,7 @@ static void added_object(unsigned nr, enum object_type type,
* to be checked at the end.
*/
static void write_object(unsigned nr, enum object_type type,
- void *buf, unsigned long size)
+ void *buf, size_t size)
{
if (!strict) {
if (odb_write_object(the_repository->objects, buf, size, type,
@@ -310,8 +310,8 @@ static void write_object(unsigned nr, enum object_type type,
}
static void resolve_delta(unsigned nr, enum object_type type,
- void *base, unsigned long base_size,
- void *delta, unsigned long delta_size)
+ void *base, size_t base_size,
+ void *delta, size_t delta_size)
{
void *result;
size_t result_size;
@@ -330,7 +330,7 @@ static void resolve_delta(unsigned nr, enum object_type type,
* resolve all the deltified objects that are based on it.
*/
static void added_object(unsigned nr, enum object_type type,
- void *data, unsigned long size)
+ void *data, size_t size)
{
struct delta_info **p = &delta_list;
struct delta_info *info;
@@ -349,7 +349,7 @@ static void added_object(unsigned nr, enum object_type type,
}
}
-static void unpack_non_delta_entry(enum object_type type, unsigned long size,
+static void unpack_non_delta_entry(enum object_type type, size_t size,
unsigned nr)
{
void *buf = get_data(size);
@@ -386,7 +386,7 @@ static ssize_t zlib_stream_read(struct odb_stream *in_stream,
return buf_len - zstream->avail_out;
}
-static void stream_blob(unsigned long size, unsigned nr)
+static void stream_blob(size_t size, unsigned nr)
{
git_zstream zstream = { 0 };
struct zlib_stream in_stream = {
@@ -420,7 +420,7 @@ static void stream_blob(unsigned long size, unsigned nr)
}
static int resolve_against_held(unsigned nr, const struct object_id *base,
- void *delta_data, unsigned long delta_size)
+ void *delta_data, size_t delta_size)
{
struct object *obj;
struct obj_buffer *obj_buffer;
@@ -435,12 +435,11 @@ static int resolve_against_held(unsigned nr, const struct object_id *base,
return 1;
}
-static void unpack_delta_entry(enum object_type type, unsigned long delta_size,
+static void unpack_delta_entry(enum object_type type, size_t delta_size,
unsigned nr)
{
void *delta_data, *base;
- unsigned long base_size;
- size_t base_size_st = 0;
+ size_t base_size = 0;
struct object_id base_oid;
if (type == OBJ_REF_DELTA) {
@@ -517,8 +516,7 @@ static void unpack_delta_entry(enum object_type type, unsigned long delta_size,
return;
base = odb_read_object(the_repository->objects, &base_oid,
- &type, &base_size_st);
- base_size = cast_size_t_to_ulong(base_size_st);
+ &type, &base_size);
if (!base) {
error("failed to read delta-pack base object %s",
oid_to_hex(&base_oid));
--
2.53.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH 2/4] index-pack: use size_t in write_compressed()
2026-10-31 11:39 [PATCH 0/4] use size_t when receiving and verifying packs Elia Pinto
2026-10-31 11:39 ` [PATCH 1/4] unpack-objects: use size_t for object sizes Elia Pinto
@ 2026-10-31 11:39 ` Elia Pinto
2026-10-31 11:39 ` [PATCH 3/4] index-pack: use size_t for object sizes Elia Pinto
` (2 subsequent siblings)
4 siblings, 0 replies; 14+ messages in thread
From: Elia Pinto @ 2026-10-31 11:39 UTC (permalink / raw)
To: git; +Cc: Johannes Schindelin, Elia Pinto, Junio C Hamano
write_compressed() in builtin/index-pack.c takes the object size as an
"unsigned int" and returns an "int", which are 32 bits wide on all
platforms. It is used by append_obj_to_pack() when resolving thin packs
with --fix-thin.
With a local base of 4GiB or more, write_compressed() compresses only
the first "size mod 2^32" bytes, while the pack header written by
append_obj_to_pack() records the full size. Later, when resolving deltas
against that base, unpack_data() encounters an early end of stream and
dies with "serious inflate inconsistency". Shrinking the parameter to 16
bits and using a 100KiB base makes "git index-pack --fix-thin" die the
same way.
Use size_t for both the size parameter and the return value.
Triggering this requires processing a local base of 4GiB or more, so
no test is added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
---
builtin/index-pack.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/builtin/index-pack.c b/builtin/index-pack.c
index 0264c18c5f..f65228468b 100644
--- a/builtin/index-pack.c
+++ b/builtin/index-pack.c
@@ -1411,7 +1411,7 @@ static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned cha
nr_ofs_deltas + nr_ref_deltas - nr_resolved_deltas);
}
-static int write_compressed(struct hashfile *f, void *in, unsigned int size)
+static size_t write_compressed(struct hashfile *f, void *in, size_t size)
{
git_zstream stream;
int status;
--
2.53.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH 3/4] index-pack: use size_t for object sizes
2026-10-31 11:39 [PATCH 0/4] use size_t when receiving and verifying packs Elia Pinto
2026-10-31 11:39 ` [PATCH 1/4] unpack-objects: use size_t for object sizes Elia Pinto
2026-10-31 11:39 ` [PATCH 2/4] index-pack: use size_t in write_compressed() Elia Pinto
@ 2026-10-31 11:39 ` Elia Pinto
2026-10-31 11:39 ` [PATCH 4/4] pack-check: use size_t for the size passed to verify callbacks Elia Pinto
2026-11-18 6:56 ` [PATCH v2 0/4] use size_t when receiving and verifying packs Elia Pinto
4 siblings, 0 replies; 14+ messages in thread
From: Elia Pinto @ 2026-10-31 11:39 UTC (permalink / raw)
To: git
Cc: Johannes Schindelin, Elia Pinto, Jonathan Tan, Junio C Hamano,
Patrick Steinhardt
Functions like sha1_object() and append_obj_to_pack() in
builtin/index-pack.c take object sizes as an "unsigned long", even
though struct object_entry already tracks them as size_t. On platforms
where "long" is 32 bits, this truncates the size for objects of 4GiB or
more.
When receiving, on those platforms, a large object that already exists
locally, sha1_object() compares the real size (size_t) against the
truncated size, resulting in a false "SHA1 COLLISION FOUND" error and
aborting index-pack.
Use size_t for the size parameter across these functions.
Triggering this requires processing 4GiB or more of input on a platform
where "long" is 32 bits, so no test is added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
---
builtin/index-pack.c | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/builtin/index-pack.c b/builtin/index-pack.c
index f65228468b..d4c073654d 100644
--- a/builtin/index-pack.c
+++ b/builtin/index-pack.c
@@ -588,7 +588,7 @@ static void *unpack_raw_entry(struct object_entry *obj,
}
static void *unpack_data(struct object_entry *obj,
- int (*consume)(const unsigned char *, unsigned long, void *),
+ int (*consume)(const unsigned char *, size_t, void *),
void *cb_data)
{
off_t from = obj[0].idx.offset + obj[0].hdr_size;
@@ -765,10 +765,10 @@ struct compare_data {
struct object_entry *entry;
struct odb_stream *st;
unsigned char *buf;
- unsigned long buf_size;
+ size_t buf_size;
};
-static int compare_objects(const unsigned char *buf, unsigned long size,
+static int compare_objects(const unsigned char *buf, size_t size,
void *cb_data)
{
struct compare_data *data = cb_data;
@@ -881,7 +881,7 @@ static void do_record_outgoing_links(struct object *obj)
}
static void sha1_object(const void *data, struct object_entry *obj_entry,
- unsigned long size, enum object_type type,
+ size_t size, enum object_type type,
const struct object_id *oid)
{
void *new_data = NULL;
@@ -1438,11 +1438,11 @@ static size_t write_compressed(struct hashfile *f, void *in, size_t size)
static struct object_entry *append_obj_to_pack(struct hashfile *f,
const unsigned char *sha1, void *buf,
- unsigned long size, enum object_type type)
+ size_t size, enum object_type type)
{
struct object_entry *obj = &objects[nr_objects++];
unsigned char header[10];
- unsigned long s = size;
+ size_t s = size;
int n = 0;
unsigned char c = (type << 4) | (s & 15);
s >>= 4;
--
2.53.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH 4/4] pack-check: use size_t for the size passed to verify callbacks
2026-10-31 11:39 [PATCH 0/4] use size_t when receiving and verifying packs Elia Pinto
` (2 preceding siblings ...)
2026-10-31 11:39 ` [PATCH 3/4] index-pack: use size_t for object sizes Elia Pinto
@ 2026-10-31 11:39 ` Elia Pinto
2026-11-18 6:56 ` [PATCH v2 0/4] use size_t when receiving and verifying packs Elia Pinto
4 siblings, 0 replies; 14+ messages in thread
From: Elia Pinto @ 2026-10-31 11:39 UTC (permalink / raw)
To: git; +Cc: Johannes Schindelin, Elia Pinto, Junio C Hamano,
Patrick Steinhardt
verify_pack() in pack-check.c passes each object to a verify_fn callback
(defined in pack.h) taking the object size as an "unsigned long", even
though pack-check already handles it as a size_t. This signature is also
replicated in struct odb_fsck_options (odb.h) and implemented by
fsck_obj_buffer() in builtin/fsck.c.
On platforms where "long" is 32 bits, running "git fsck" on packs with
objects of 4GiB or more passes a truncated size to fsck_obj_buffer(),
causing parse_object_buffer() and fsck_object() to inspect only a
prefix.
Use size_t for the size parameter in verify_fn,
struct odb_fsck_options.object_cb, and fsck_obj_buffer().
Triggering this requires processing objects of 4GiB or more on a
platform where "long" is 32 bits, so no test is added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
---
builtin/fsck.c | 2 +-
odb.h | 2 +-
pack.h | 2 +-
3 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/builtin/fsck.c b/builtin/fsck.c
index da90cf84bf..9f62aa1f4e 100644
--- a/builtin/fsck.c
+++ b/builtin/fsck.c
@@ -390,7 +390,7 @@ static void check_connectivity(struct repository *repo)
}
static int fsck_obj_buffer(const struct object_id *oid, enum object_type type,
- unsigned long size, void *buffer, int *eaten, void *cb_data)
+ size_t size, void *buffer, int *eaten, void *cb_data)
{
struct repository *repo = cb_data;
struct object *obj;
diff --git a/odb.h b/odb.h
index dd85b880a7..9cb36ed5ad 100644
--- a/odb.h
+++ b/odb.h
@@ -197,7 +197,7 @@ struct odb_fsck_options {
enum odb_fsck_flags flags;
int (*object_cb)(const struct object_id *oid, enum object_type type,
- unsigned long size, void *buffer, int *eaten, void *cb_data);
+ size_t size, void *buffer, int *eaten, void *cb_data);
void *object_payload;
};
diff --git a/pack.h b/pack.h
index ada506b5c5..d9649c6ee0 100644
--- a/pack.h
+++ b/pack.h
@@ -88,7 +88,7 @@ struct progress;
/* Note, the data argument could be NULL if object type is blob */
typedef int (*verify_fn)(const struct object_id *oid,
enum object_type type,
- unsigned long size,
+ size_t size,
void *buffer, int *eaten,
void *fn_data);
--
2.53.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH v2 0/4] use size_t when receiving and verifying packs
2026-10-31 11:39 [PATCH 0/4] use size_t when receiving and verifying packs Elia Pinto
` (3 preceding siblings ...)
2026-10-31 11:39 ` [PATCH 4/4] pack-check: use size_t for the size passed to verify callbacks Elia Pinto
@ 2026-11-18 6:56 ` Elia Pinto
2026-11-18 6:56 ` [PATCH v2 1/4] unpack-objects: use size_t for object sizes Elia Pinto
` (3 more replies)
4 siblings, 4 replies; 14+ messages in thread
From: Elia Pinto @ 2026-11-18 6:56 UTC (permalink / raw)
To: git
Cc: Johannes Schindelin, Elia Pinto, Justin Tobler, Han Xin, Han Xin,
Ævar Arnfjörð Bjarmason, Patrick Steinhardt,
Junio C Hamano, Jonathan Tan, Kristofer Karlsson
This series fixes object sizes that are truncated when receiving and
verifying packs. Most of them are kept in an "unsigned long", which is
a problem where "long" is 32 bits while size_t is 64, such as on 64-bit
Windows; 2/4 is about an "unsigned int", which is 32 bits everywhere.
1/4 unpack-objects fails with "inflate returned -5" on an object of
4GiB or more that is not streamed, dies on a delta base that
large, and silently writes a truncated object for a delta result
that large. With 1/4, "unpack-objects -n" and large delta bases
work, and writing such an object, unless it is streamed, dies
with a clear error.
2/4 "index-pack --fix-thin" with a local base of 4GiB or more
compresses only part of it and dies later with "serious inflate
inconsistency" (all platforms).
3/4 index-pack reports a false "SHA1 COLLISION FOUND" for a large
object that already exists locally.
4/4 "git fsck" checks only a prefix of large objects in packs.
None of them comes with a test, as each needs an object of 4GiB or
more; 1/4 and 2/4 describe how I checked them with the size truncated
to 16 bits.
Changes since v1:
- Rebased onto master at e1ec09b23c (The 22nd batch). v1's 1/4 no
longer applied: e07ac16d1c (unpack-objects: pass the size of a
streamed blob as size_t, 2026-11-06) by Kristofer Karlsson, now in
master, makes the same change to stream_blob(). 1/4 drops that hunk;
Kristofer is Cc'd.
- The message of 1/4 used stream_blob() as its only example, so it is
rewritten around the paths that are still affected: objects that
are not streamed, all blobs with "git unpack-objects -n", and
deltas.
- 1/4 no longer drops the cast_size_t_to_ulong() in
unpack_delta_entry(), but moves it to write_object(), where the size
is passed to odb_write_object() and parse_object_buffer(). v1 let
objects of 4GiB or more reach these functions and be written
truncated.
- 4/4 says that parse_object_buffer() and fsck_object() still see a
truncated size until they take a size_t.
- The messages of 1/4, 3/4 and 4/4 now say that the problem is "long"
being 32 bits while size_t is 64. The code of 2/4, 3/4 and 4/4 is
unchanged.
There were no comments on v1.
v1 left pack-objects for a later series. That fix has since been
merged as ep/pack-objects-streamed-large-blobs-fix (ed0aed1e17); it
covers the streamed path and explains why the other truncations in
pack-objects cannot be reached.
The callees odb_write_object(), parse_object_buffer() and
fsck_object() still take an "unsigned long" on master. They are changed
by two other series of mine, which are not queued yet:
https://lore.kernel.org/git/cover.1793444420.git.gitter.spiros@gmail.com/
https://lore.kernel.org/git/cover.1793439137.git.gitter.spiros@gmail.com/
The series is based on master at e1ec09b23c.
Elia Pinto (4):
unpack-objects: use size_t for object sizes
index-pack: use size_t in write_compressed()
index-pack: use size_t for object sizes
pack-check: use size_t for the size passed to verify callbacks
builtin/fsck.c | 2 +-
builtin/index-pack.c | 14 +++++++-------
builtin/unpack-objects.c | 42 ++++++++++++++++++++--------------------
odb.h | 2 +-
pack.h | 2 +-
5 files changed, 31 insertions(+), 31 deletions(-)
Range-diff against v1:
1: f259eeb6a6 ! 1: b2c3d349a4 unpack-objects: use size_t for object sizes
@@ Metadata
## Commit message ##
unpack-objects: use size_t for object sizes
- builtin/unpack-objects.c uses "unsigned long" to track object sizes
- throughout the file, while sizes read from packs are handled as size_t.
- On platforms where "long" is 32 bits, this truncates the size for
- objects of 4GiB or more.
+ Since f2063855fb (index-pack, unpack-objects: use size_t for object
+ size, 2026-05-08), unpack_one() decodes the size of an object into a
+ size_t, and e07ac16d1c (unpack-objects: pass the size of a streamed
+ blob as size_t, 2026-11-06) passes it on as such to stream_blob(),
+ which handles blobs larger than core.bigFileThreshold. The rest of
+ builtin/unpack-objects.c still takes the size as an "unsigned long":
- When handling large objects on those platforms, unpack-objects fails
- rather than corrupting data. For instance, streaming large blobs
- (exceeding core.bigFileThreshold) passes a truncated size to
- stream_blob(), causing the stream write to fail with an error.
+ - unpack_non_delta_entry() and get_data(), used for commits, trees,
+ tags and blobs below core.bigFileThreshold, and for all blobs with
+ "git unpack-objects -n", which never streams;
- Use size_t across the board in builtin/unpack-objects.c and remove the
- now-unnecessary size cast in unpack_delta_entry(). Downstream consumers
- like odb_write_object() and fsck_object() are updated separately.
+ - unpack_delta_entry() and the functions that keep and resolve
+ deltas;
- Triggering this requires processing 4GiB or more of input on a platform
- where "long" is 32 bits, so no test is added.
+ - struct obj_buffer, which keeps objects around for --strict.
+
+ On platforms where "long" is 32 bits while size_t is 64, such as 64-bit
+ Windows, the size of an object of 4GiB or more is therefore truncated:
+
+ - For an object that is not streamed, get_data() allocates a buffer
+ of the truncated size, inflate runs out of room in it, and
+ unpack-objects fails with "inflate returned -5". Truncating the
+ size to 16 bits in get_data() and unpack_non_delta_entry()
+ reproduces this with a pack holding a 70000-byte blob, both with
+ and without -n.
+
+ - unpack_delta_entry() reads the base of a delta through
+ cast_size_t_to_ulong(), so a base of 4GiB or more makes it die even
+ when the result would be smaller.
+
+ - The result of a delta reaches write_object() as a size_t, but
+ write_object() takes it as an "unsigned long". A result of 4GiB or
+ more is silently truncated there, and an object with the wrong
+ contents, hence the wrong name, is written.
+
+ Use size_t across builtin/unpack-objects.c. The functions that
+ write_object() hands objects to, odb_write_object() and
+ parse_object_buffer(), still take an "unsigned long", as does
+ fsck_object(); they are updated separately. Until then, move the size
+ cast from unpack_delta_entry() to write_object(), where the size is
+ passed to them. fsck_object() only sees objects that went through
+ parse_object_buffer() first, and so does write_cached_object(), which
+ writes them out later; neither needs a cast of its own.
+
+ As a result, on those platforms:
+
+ - "git unpack-objects -n" handles objects of any size;
+
+ - a delta with a base of 4GiB or more and a smaller result is
+ resolved;
+
+ - an object of 4GiB or more that is not streamed and has to be
+ written, including the result of a delta, makes unpack-objects die
+ with "object too large to read on this platform" instead of failing
+ with "inflate returned -5" or being written truncated.
+
+ Truncating the size to 16 bits where write_object() passes it on
+ confirms the last point for a 70000-byte blob: with the cast,
+ unpack-objects dies with "object too large to read on this platform:
+ 70000 is cut off to 4464"; without it, it exits with 0 and writes a
+ truncated blob under another name.
+
+ Triggering this requires processing an object of 4GiB or more on a
+ platform where "long" is 32 bits while size_t is 64, so no test is
+ added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
@@ builtin/unpack-objects.c: static void added_object(unsigned nr, enum object_type
+ void *buf, size_t size)
{
if (!strict) {
- if (odb_write_object(the_repository->objects, buf, size, type,
+- if (odb_write_object(the_repository->objects, buf, size, type,
++ if (odb_write_object(the_repository->objects, buf,
++ cast_size_t_to_ulong(size), type,
+ &obj_list[nr].oid) < 0)
+ die("failed to write object");
+ added_object(nr, type, buf, size);
+@@ builtin/unpack-objects.c: static void write_object(unsigned nr, enum object_type type,
+ obj_list[nr].obj = NULL;
+ } else if (type == OBJ_BLOB) {
+ struct blob *blob;
+- if (odb_write_object(the_repository->objects, buf, size, type,
++ if (odb_write_object(the_repository->objects, buf,
++ cast_size_t_to_ulong(size), type,
+ &obj_list[nr].oid) < 0)
+ die("failed to write object");
+ added_object(nr, type, buf, size);
+@@ builtin/unpack-objects.c: static void write_object(unsigned nr, enum object_type type,
+ &obj_list[nr].oid);
+ added_object(nr, type, buf, size);
+ obj = parse_object_buffer(the_repository, &obj_list[nr].oid,
+- type, size, buf,
++ type, cast_size_t_to_ulong(size), buf,
+ &eaten);
+ if (!obj)
+ die("invalid %s", type_name(type));
@@ builtin/unpack-objects.c: static void write_object(unsigned nr, enum object_type type,
}
@@ builtin/unpack-objects.c: static void added_object(unsigned nr, enum object_type
unsigned nr)
{
void *buf = get_data(size);
-@@ builtin/unpack-objects.c: static ssize_t zlib_stream_read(struct odb_stream *in_stream,
- return buf_len - zstream->avail_out;
- }
-
--static void stream_blob(unsigned long size, unsigned nr)
-+static void stream_blob(size_t size, unsigned nr)
- {
- git_zstream zstream = { 0 };
- struct zlib_stream in_stream = {
-@@ builtin/unpack-objects.c: static void stream_blob(unsigned long size, unsigned nr)
+@@ builtin/unpack-objects.c: static void stream_blob(size_t size, unsigned nr)
}
static int resolve_against_held(unsigned nr, const struct object_id *base,
2: 438f7c6ba2 = 2: 9952f0fb10 index-pack: use size_t in write_compressed()
3: 0258282745 ! 3: e66860d274 index-pack: use size_t for object sizes
@@ Commit message
Functions like sha1_object() and append_obj_to_pack() in
builtin/index-pack.c take object sizes as an "unsigned long", even
though struct object_entry already tracks them as size_t. On platforms
- where "long" is 32 bits, this truncates the size for objects of 4GiB or
- more.
+ where "long" is 32 bits while size_t is 64, such as 64-bit Windows,
+ this truncates the size of objects of 4GiB or more.
When receiving, on those platforms, a large object that already exists
locally, sha1_object() compares the real size (size_t) against the
@@ Commit message
Use size_t for the size parameter across these functions.
Triggering this requires processing 4GiB or more of input on a platform
- where "long" is 32 bits, so no test is added.
+ where "long" is 32 bits while size_t is 64, so no test is added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
4: 87b0d2bd96 ! 4: 00939c7f1b pack-check: use size_t for the size passed to verify callbacks
@@ Commit message
replicated in struct odb_fsck_options (odb.h) and implemented by
fsck_obj_buffer() in builtin/fsck.c.
- On platforms where "long" is 32 bits, running "git fsck" on packs with
- objects of 4GiB or more passes a truncated size to fsck_obj_buffer(),
- causing parse_object_buffer() and fsck_object() to inspect only a
- prefix.
+ On platforms where "long" is 32 bits while size_t is 64, such as
+ 64-bit Windows, running "git fsck" on packs with objects of 4GiB or
+ more passes a truncated size to fsck_obj_buffer(), causing
+ parse_object_buffer() and fsck_object() to inspect only a prefix.
Use size_t for the size parameter in verify_fn,
struct odb_fsck_options.object_cb, and fsck_obj_buffer().
+ parse_object_buffer() and fsck_object() themselves still take an
+ "unsigned long"; until they are updated separately, they keep
+ inspecting only a prefix.
Triggering this requires processing objects of 4GiB or more on a
- platform where "long" is 32 bits, so no test is added.
+ platform where "long" is 32 bits while size_t is 64, so no test is
+ added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
base-commit: e1ec09b23c8e0deb21a0b95ac5996422277395d4
--
2.53.0
^ permalink raw reply [flat|nested] 14+ messages in thread* [PATCH v2 1/4] unpack-objects: use size_t for object sizes
2026-11-18 6:56 ` [PATCH v2 0/4] use size_t when receiving and verifying packs Elia Pinto
@ 2026-11-18 6:56 ` Elia Pinto
2026-11-18 13:33 ` Patrick Steinhardt
2026-11-18 6:56 ` [PATCH v2 2/4] index-pack: use size_t in write_compressed() Elia Pinto
` (2 subsequent siblings)
3 siblings, 1 reply; 14+ messages in thread
From: Elia Pinto @ 2026-11-18 6:56 UTC (permalink / raw)
To: git
Cc: Johannes Schindelin, Elia Pinto, Kristofer Karlsson, Han Xin,
Han Xin, Junio C Hamano, Ævar Arnfjörð Bjarmason,
Patrick Steinhardt
Since f2063855fb (index-pack, unpack-objects: use size_t for object
size, 2026-05-08), unpack_one() decodes the size of an object into a
size_t, and e07ac16d1c (unpack-objects: pass the size of a streamed
blob as size_t, 2026-11-06) passes it on as such to stream_blob(),
which handles blobs larger than core.bigFileThreshold. The rest of
builtin/unpack-objects.c still takes the size as an "unsigned long":
- unpack_non_delta_entry() and get_data(), used for commits, trees,
tags and blobs below core.bigFileThreshold, and for all blobs with
"git unpack-objects -n", which never streams;
- unpack_delta_entry() and the functions that keep and resolve
deltas;
- struct obj_buffer, which keeps objects around for --strict.
On platforms where "long" is 32 bits while size_t is 64, such as 64-bit
Windows, the size of an object of 4GiB or more is therefore truncated:
- For an object that is not streamed, get_data() allocates a buffer
of the truncated size, inflate runs out of room in it, and
unpack-objects fails with "inflate returned -5". Truncating the
size to 16 bits in get_data() and unpack_non_delta_entry()
reproduces this with a pack holding a 70000-byte blob, both with
and without -n.
- unpack_delta_entry() reads the base of a delta through
cast_size_t_to_ulong(), so a base of 4GiB or more makes it die even
when the result would be smaller.
- The result of a delta reaches write_object() as a size_t, but
write_object() takes it as an "unsigned long". A result of 4GiB or
more is silently truncated there, and an object with the wrong
contents, hence the wrong name, is written.
Use size_t across builtin/unpack-objects.c. The functions that
write_object() hands objects to, odb_write_object() and
parse_object_buffer(), still take an "unsigned long", as does
fsck_object(); they are updated separately. Until then, move the size
cast from unpack_delta_entry() to write_object(), where the size is
passed to them. fsck_object() only sees objects that went through
parse_object_buffer() first, and so does write_cached_object(), which
writes them out later; neither needs a cast of its own.
As a result, on those platforms:
- "git unpack-objects -n" handles objects of any size;
- a delta with a base of 4GiB or more and a smaller result is
resolved;
- an object of 4GiB or more that is not streamed and has to be
written, including the result of a delta, makes unpack-objects die
with "object too large to read on this platform" instead of failing
with "inflate returned -5" or being written truncated.
Truncating the size to 16 bits where write_object() passes it on
confirms the last point for a 70000-byte blob: with the cast,
unpack-objects dies with "object too large to read on this platform:
70000 is cut off to 4464"; without it, it exits with 0 and writes a
truncated blob under another name.
Triggering this requires processing an object of 4GiB or more on a
platform where "long" is 32 bits while size_t is 64, so no test is
added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
---
builtin/unpack-objects.c | 42 ++++++++++++++++++++--------------------
1 file changed, 21 insertions(+), 21 deletions(-)
diff --git a/builtin/unpack-objects.c b/builtin/unpack-objects.c
index d2f25bed49..9bd355b2c4 100644
--- a/builtin/unpack-objects.c
+++ b/builtin/unpack-objects.c
@@ -40,7 +40,7 @@ static struct progress *progress;
*/
struct obj_buffer {
char *buffer;
- unsigned long size;
+ size_t size;
};
static struct decoration obj_decorate;
@@ -50,7 +50,7 @@ static struct obj_buffer *lookup_object_buffer(struct object *base)
return lookup_decoration(&obj_decorate, base);
}
-static void add_object_buffer(struct object *object, char *buffer, unsigned long size)
+static void add_object_buffer(struct object *object, char *buffer, size_t size)
{
struct obj_buffer *obj;
CALLOC_ARRAY(obj, 1);
@@ -114,10 +114,10 @@ static void use(int bytes)
* allocated buffer which is reused to hold temporary zstream output
* and return NULL instead of returning garbage data.
*/
-static void *get_data(unsigned long size)
+static void *get_data(size_t size)
{
git_zstream stream;
- unsigned long bufsize = dry_run && size > 8192 ? 8192 : size;
+ size_t bufsize = dry_run && size > 8192 ? 8192 : size;
void *buf = xmallocz(bufsize);
memset(&stream, 0, sizeof(stream));
@@ -161,7 +161,7 @@ struct delta_info {
struct object_id base_oid;
unsigned nr;
off_t base_offset;
- unsigned long size;
+ size_t size;
void *delta;
struct delta_info *next;
};
@@ -170,7 +170,7 @@ static struct delta_info *delta_list;
static void add_delta_to_list(unsigned nr, const struct object_id *base_oid,
off_t base_offset,
- void *delta, unsigned long size)
+ void *delta, size_t size)
{
struct delta_info *info = xmalloc(sizeof(*info));
@@ -261,7 +261,7 @@ static void write_rest(void)
}
static void added_object(unsigned nr, enum object_type type,
- void *data, unsigned long size);
+ void *data, size_t size);
/*
* Write out nr-th object from the list, now we know the contents
@@ -269,10 +269,11 @@ static void added_object(unsigned nr, enum object_type type,
* to be checked at the end.
*/
static void write_object(unsigned nr, enum object_type type,
- void *buf, unsigned long size)
+ void *buf, size_t size)
{
if (!strict) {
- if (odb_write_object(the_repository->objects, buf, size, type,
+ if (odb_write_object(the_repository->objects, buf,
+ cast_size_t_to_ulong(size), type,
&obj_list[nr].oid) < 0)
die("failed to write object");
added_object(nr, type, buf, size);
@@ -280,7 +281,8 @@ static void write_object(unsigned nr, enum object_type type,
obj_list[nr].obj = NULL;
} else if (type == OBJ_BLOB) {
struct blob *blob;
- if (odb_write_object(the_repository->objects, buf, size, type,
+ if (odb_write_object(the_repository->objects, buf,
+ cast_size_t_to_ulong(size), type,
&obj_list[nr].oid) < 0)
die("failed to write object");
added_object(nr, type, buf, size);
@@ -299,7 +301,7 @@ static void write_object(unsigned nr, enum object_type type,
&obj_list[nr].oid);
added_object(nr, type, buf, size);
obj = parse_object_buffer(the_repository, &obj_list[nr].oid,
- type, size, buf,
+ type, cast_size_t_to_ulong(size), buf,
&eaten);
if (!obj)
die("invalid %s", type_name(type));
@@ -310,8 +312,8 @@ static void write_object(unsigned nr, enum object_type type,
}
static void resolve_delta(unsigned nr, enum object_type type,
- void *base, unsigned long base_size,
- void *delta, unsigned long delta_size)
+ void *base, size_t base_size,
+ void *delta, size_t delta_size)
{
void *result;
size_t result_size;
@@ -330,7 +332,7 @@ static void resolve_delta(unsigned nr, enum object_type type,
* resolve all the deltified objects that are based on it.
*/
static void added_object(unsigned nr, enum object_type type,
- void *data, unsigned long size)
+ void *data, size_t size)
{
struct delta_info **p = &delta_list;
struct delta_info *info;
@@ -349,7 +351,7 @@ static void added_object(unsigned nr, enum object_type type,
}
}
-static void unpack_non_delta_entry(enum object_type type, unsigned long size,
+static void unpack_non_delta_entry(enum object_type type, size_t size,
unsigned nr)
{
void *buf = get_data(size);
@@ -420,7 +422,7 @@ static void stream_blob(size_t size, unsigned nr)
}
static int resolve_against_held(unsigned nr, const struct object_id *base,
- void *delta_data, unsigned long delta_size)
+ void *delta_data, size_t delta_size)
{
struct object *obj;
struct obj_buffer *obj_buffer;
@@ -435,12 +437,11 @@ static int resolve_against_held(unsigned nr, const struct object_id *base,
return 1;
}
-static void unpack_delta_entry(enum object_type type, unsigned long delta_size,
+static void unpack_delta_entry(enum object_type type, size_t delta_size,
unsigned nr)
{
void *delta_data, *base;
- unsigned long base_size;
- size_t base_size_st = 0;
+ size_t base_size = 0;
struct object_id base_oid;
if (type == OBJ_REF_DELTA) {
@@ -517,8 +518,7 @@ static void unpack_delta_entry(enum object_type type, unsigned long delta_size,
return;
base = odb_read_object(the_repository->objects, &base_oid,
- &type, &base_size_st);
- base_size = cast_size_t_to_ulong(base_size_st);
+ &type, &base_size);
if (!base) {
error("failed to read delta-pack base object %s",
oid_to_hex(&base_oid));
--
2.53.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* Re: [PATCH v2 1/4] unpack-objects: use size_t for object sizes
2026-11-18 6:56 ` [PATCH v2 1/4] unpack-objects: use size_t for object sizes Elia Pinto
@ 2026-11-18 13:33 ` Patrick Steinhardt
2026-11-18 16:59 ` Junio C Hamano
0 siblings, 1 reply; 14+ messages in thread
From: Patrick Steinhardt @ 2026-11-18 13:33 UTC (permalink / raw)
To: Elia Pinto
Cc: git, Johannes Schindelin, Kristofer Karlsson, Han Xin, Han Xin,
Junio C Hamano, Ævar Arnfjörð Bjarmason
On Wed, Nov 18, 2026 at 07:56:35AM +0100, Elia Pinto wrote:
> Since f2063855fb (index-pack, unpack-objects: use size_t for object
> size, 2026-05-08), unpack_one() decodes the size of an object into a
> size_t, and e07ac16d1c (unpack-objects: pass the size of a streamed
> blob as size_t, 2026-11-06) passes it on as such to stream_blob(),
> which handles blobs larger than core.bigFileThreshold. The rest of
> builtin/unpack-objects.c still takes the size as an "unsigned long":
>
> - unpack_non_delta_entry() and get_data(), used for commits, trees,
> tags and blobs below core.bigFileThreshold, and for all blobs with
> "git unpack-objects -n", which never streams;
>
> - unpack_delta_entry() and the functions that keep and resolve
> deltas;
>
> - struct obj_buffer, which keeps objects around for --strict.
>
> On platforms where "long" is 32 bits while size_t is 64, such as 64-bit
> Windows, the size of an object of 4GiB or more is therefore truncated:
>
> - For an object that is not streamed, get_data() allocates a buffer
> of the truncated size, inflate runs out of room in it, and
> unpack-objects fails with "inflate returned -5". Truncating the
> size to 16 bits in get_data() and unpack_non_delta_entry()
> reproduces this with a pack holding a 70000-byte blob, both with
> and without -n.
>
> - unpack_delta_entry() reads the base of a delta through
> cast_size_t_to_ulong(), so a base of 4GiB or more makes it die even
> when the result would be smaller.
>
> - The result of a delta reaches write_object() as a size_t, but
> write_object() takes it as an "unsigned long". A result of 4GiB or
> more is silently truncated there, and an object with the wrong
> contents, hence the wrong name, is written.
>
> Use size_t across builtin/unpack-objects.c. The functions that
> write_object() hands objects to, odb_write_object() and
> parse_object_buffer(), still take an "unsigned long", as does
> fsck_object(); they are updated separately. Until then, move the size
> cast from unpack_delta_entry() to write_object(), where the size is
> passed to them. fsck_object() only sees objects that went through
> parse_object_buffer() first, and so does write_cached_object(), which
> writes them out later; neither needs a cast of its own.
>
> As a result, on those platforms:
>
> - "git unpack-objects -n" handles objects of any size;
>
> - a delta with a base of 4GiB or more and a smaller result is
> resolved;
>
> - an object of 4GiB or more that is not streamed and has to be
> written, including the result of a delta, makes unpack-objects die
> with "object too large to read on this platform" instead of failing
> with "inflate returned -5" or being written truncated.
>
> Truncating the size to 16 bits where write_object() passes it on
> confirms the last point for a 70000-byte blob: with the cast,
> unpack-objects dies with "object too large to read on this platform:
> 70000 is cut off to 4464"; without it, it exits with 0 and writes a
> truncated blob under another name.
>
> Triggering this requires processing an object of 4GiB or more on a
> platform where "long" is 32 bits while size_t is 64, so no test is
> added.
Phew, this commit message really is extremely verbose, and I eventually
lost steam reading through it halfways. It's good to document what
you're doing, but this here might have gone off the rails a bit with
that.
What's worth documenting is the unexpected parts in your patch, and
things that may not be immediately obvious to a reviewer. But you also
document what specifically you are doing to what function, and that's
quite obvious from the diff itself. So overall I bet that this message
could be condensed to half or even a third of its size without losing
much information.
> diff --git a/builtin/unpack-objects.c b/builtin/unpack-objects.c
> index d2f25bed49..9bd355b2c4 100644
> --- a/builtin/unpack-objects.c
> +++ b/builtin/unpack-objects.c
> @@ -269,10 +269,11 @@ static void added_object(unsigned nr, enum object_type type,
> * to be checked at the end.
> */
> static void write_object(unsigned nr, enum object_type type,
> - void *buf, unsigned long size)
> + void *buf, size_t size)
> {
> if (!strict) {
> - if (odb_write_object(the_repository->objects, buf, size, type,
> + if (odb_write_object(the_repository->objects, buf,
> + cast_size_t_to_ulong(size), type,
> &obj_list[nr].oid) < 0)
> die("failed to write object");
> added_object(nr, type, buf, size);
These casts here make me a bit unhappy, as you also have a patch series
in flight that fix `odb_write_object()`. So you'll have to send another
patch series after both have landed to remove those again.
Would it make more sense to defer this series here until the other one
lands?
> @@ -299,7 +301,7 @@ static void write_object(unsigned nr, enum object_type type,
> &obj_list[nr].oid);
> added_object(nr, type, buf, size);
> obj = parse_object_buffer(the_repository, &obj_list[nr].oid,
> - type, size, buf,
> + type, cast_size_t_to_ulong(size), buf,
> &eaten);
> if (!obj)
> die("invalid %s", type_name(type));
Likewise, even though I don't know whether you also have a patch series
in flight fixing this one from the top of my head.
Patrick
^ permalink raw reply [flat|nested] 14+ messages in thread* Re: [PATCH v2 1/4] unpack-objects: use size_t for object sizes
2026-11-18 13:33 ` Patrick Steinhardt
@ 2026-11-18 16:59 ` Junio C Hamano
0 siblings, 0 replies; 14+ messages in thread
From: Junio C Hamano @ 2026-11-18 16:59 UTC (permalink / raw)
To: Patrick Steinhardt
Cc: Elia Pinto, git, Johannes Schindelin, Kristofer Karlsson, Han Xin,
Han Xin, Ævar Arnfjörð Bjarmason
Patrick Steinhardt <ps@pks.im> writes:
> What's worth documenting is the unexpected parts in your patch, and
> things that may not be immediately obvious to a reviewer. But you also
> document what specifically you are doing to what function, and that's
> quite obvious from the diff itself. So overall I bet that this message
> could be condensed to half or even a third of its size without losing
> much information.
Good observation and matches my impression on recent proposed log
messages I see on the list, not limited to this author but by
others. Perhaps people should paste their text to their nearby
faviourite LLM and ask it to condense it down by 70% without losing
substance, and notch it down if they feel the result lost too much,
or something.
^ permalink raw reply [flat|nested] 14+ messages in thread
* [PATCH v2 2/4] index-pack: use size_t in write_compressed()
2026-11-18 6:56 ` [PATCH v2 0/4] use size_t when receiving and verifying packs Elia Pinto
2026-11-18 6:56 ` [PATCH v2 1/4] unpack-objects: use size_t for object sizes Elia Pinto
@ 2026-11-18 6:56 ` Elia Pinto
2026-11-18 13:33 ` Patrick Steinhardt
2026-11-18 6:56 ` [PATCH v2 3/4] index-pack: use size_t for object sizes Elia Pinto
2026-11-18 6:56 ` [PATCH v2 4/4] pack-check: use size_t for the size passed to verify callbacks Elia Pinto
3 siblings, 1 reply; 14+ messages in thread
From: Elia Pinto @ 2026-11-18 6:56 UTC (permalink / raw)
To: git; +Cc: Johannes Schindelin, Elia Pinto, Junio C Hamano
write_compressed() in builtin/index-pack.c takes the object size as an
"unsigned int" and returns an "int", which are 32 bits wide on all
platforms. It is used by append_obj_to_pack() when resolving thin packs
with --fix-thin.
With a local base of 4GiB or more, write_compressed() compresses only
the first "size mod 2^32" bytes, while the pack header written by
append_obj_to_pack() records the full size. Later, when resolving deltas
against that base, unpack_data() encounters an early end of stream and
dies with "serious inflate inconsistency". Shrinking the parameter to 16
bits and using a 100KiB base makes "git index-pack --fix-thin" die the
same way.
Use size_t for both the size parameter and the return value.
Triggering this requires processing a local base of 4GiB or more, so
no test is added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
---
builtin/index-pack.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/builtin/index-pack.c b/builtin/index-pack.c
index 0264c18c5f..f65228468b 100644
--- a/builtin/index-pack.c
+++ b/builtin/index-pack.c
@@ -1411,7 +1411,7 @@ static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned cha
nr_ofs_deltas + nr_ref_deltas - nr_resolved_deltas);
}
-static int write_compressed(struct hashfile *f, void *in, unsigned int size)
+static size_t write_compressed(struct hashfile *f, void *in, size_t size)
{
git_zstream stream;
int status;
--
2.53.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* Re: [PATCH v2 2/4] index-pack: use size_t in write_compressed()
2026-11-18 6:56 ` [PATCH v2 2/4] index-pack: use size_t in write_compressed() Elia Pinto
@ 2026-11-18 13:33 ` Patrick Steinhardt
0 siblings, 0 replies; 14+ messages in thread
From: Patrick Steinhardt @ 2026-11-18 13:33 UTC (permalink / raw)
To: Elia Pinto; +Cc: git, Johannes Schindelin, Junio C Hamano
On Wed, Nov 18, 2026 at 07:56:36AM +0100, Elia Pinto wrote:
> write_compressed() in builtin/index-pack.c takes the object size as an
> "unsigned int" and returns an "int", which are 32 bits wide on all
> platforms. It is used by append_obj_to_pack() when resolving thin packs
> with --fix-thin.
>
> With a local base of 4GiB or more, write_compressed() compresses only
> the first "size mod 2^32" bytes, while the pack header written by
> append_obj_to_pack() records the full size. Later, when resolving deltas
> against that base, unpack_data() encounters an early end of stream and
> dies with "serious inflate inconsistency". Shrinking the parameter to 16
> bits and using a 100KiB base makes "git index-pack --fix-thin" die the
> same way.
>
> Use size_t for both the size parameter and the return value.
Hmm. It's probably an improvement, but the only caller does this:
obj[1].idx.offset += write_compressed(f, buf, size);
That's a `struct pack_idx_entry`, but its `offset` field is of type
`off_t`, which is signed. It feels sufficiently unlikely to ever
overflow, but should we verify regardless that we don't?
> Triggering this requires processing a local base of 4GiB or more, so
> no test is added.
Not even an EXPENSIVE one?
Patrick
^ permalink raw reply [flat|nested] 14+ messages in thread
* [PATCH v2 3/4] index-pack: use size_t for object sizes
2026-11-18 6:56 ` [PATCH v2 0/4] use size_t when receiving and verifying packs Elia Pinto
2026-11-18 6:56 ` [PATCH v2 1/4] unpack-objects: use size_t for object sizes Elia Pinto
2026-11-18 6:56 ` [PATCH v2 2/4] index-pack: use size_t in write_compressed() Elia Pinto
@ 2026-11-18 6:56 ` Elia Pinto
2026-11-18 6:56 ` [PATCH v2 4/4] pack-check: use size_t for the size passed to verify callbacks Elia Pinto
3 siblings, 0 replies; 14+ messages in thread
From: Elia Pinto @ 2026-11-18 6:56 UTC (permalink / raw)
To: git
Cc: Johannes Schindelin, Elia Pinto, Jonathan Tan, Junio C Hamano,
Patrick Steinhardt
Functions like sha1_object() and append_obj_to_pack() in
builtin/index-pack.c take object sizes as an "unsigned long", even
though struct object_entry already tracks them as size_t. On platforms
where "long" is 32 bits while size_t is 64, such as 64-bit Windows,
this truncates the size of objects of 4GiB or more.
When receiving, on those platforms, a large object that already exists
locally, sha1_object() compares the real size (size_t) against the
truncated size, resulting in a false "SHA1 COLLISION FOUND" error and
aborting index-pack.
Use size_t for the size parameter across these functions.
Triggering this requires processing 4GiB or more of input on a platform
where "long" is 32 bits while size_t is 64, so no test is added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
---
builtin/index-pack.c | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/builtin/index-pack.c b/builtin/index-pack.c
index f65228468b..d4c073654d 100644
--- a/builtin/index-pack.c
+++ b/builtin/index-pack.c
@@ -588,7 +588,7 @@ static void *unpack_raw_entry(struct object_entry *obj,
}
static void *unpack_data(struct object_entry *obj,
- int (*consume)(const unsigned char *, unsigned long, void *),
+ int (*consume)(const unsigned char *, size_t, void *),
void *cb_data)
{
off_t from = obj[0].idx.offset + obj[0].hdr_size;
@@ -765,10 +765,10 @@ struct compare_data {
struct object_entry *entry;
struct odb_stream *st;
unsigned char *buf;
- unsigned long buf_size;
+ size_t buf_size;
};
-static int compare_objects(const unsigned char *buf, unsigned long size,
+static int compare_objects(const unsigned char *buf, size_t size,
void *cb_data)
{
struct compare_data *data = cb_data;
@@ -881,7 +881,7 @@ static void do_record_outgoing_links(struct object *obj)
}
static void sha1_object(const void *data, struct object_entry *obj_entry,
- unsigned long size, enum object_type type,
+ size_t size, enum object_type type,
const struct object_id *oid)
{
void *new_data = NULL;
@@ -1438,11 +1438,11 @@ static size_t write_compressed(struct hashfile *f, void *in, size_t size)
static struct object_entry *append_obj_to_pack(struct hashfile *f,
const unsigned char *sha1, void *buf,
- unsigned long size, enum object_type type)
+ size_t size, enum object_type type)
{
struct object_entry *obj = &objects[nr_objects++];
unsigned char header[10];
- unsigned long s = size;
+ size_t s = size;
int n = 0;
unsigned char c = (type << 4) | (s & 15);
s >>= 4;
--
2.53.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH v2 4/4] pack-check: use size_t for the size passed to verify callbacks
2026-11-18 6:56 ` [PATCH v2 0/4] use size_t when receiving and verifying packs Elia Pinto
` (2 preceding siblings ...)
2026-11-18 6:56 ` [PATCH v2 3/4] index-pack: use size_t for object sizes Elia Pinto
@ 2026-11-18 6:56 ` Elia Pinto
2026-11-18 13:34 ` Patrick Steinhardt
3 siblings, 1 reply; 14+ messages in thread
From: Elia Pinto @ 2026-11-18 6:56 UTC (permalink / raw)
To: git; +Cc: Johannes Schindelin, Elia Pinto, Patrick Steinhardt,
Junio C Hamano
verify_pack() in pack-check.c passes each object to a verify_fn callback
(defined in pack.h) taking the object size as an "unsigned long", even
though pack-check already handles it as a size_t. This signature is also
replicated in struct odb_fsck_options (odb.h) and implemented by
fsck_obj_buffer() in builtin/fsck.c.
On platforms where "long" is 32 bits while size_t is 64, such as
64-bit Windows, running "git fsck" on packs with objects of 4GiB or
more passes a truncated size to fsck_obj_buffer(), causing
parse_object_buffer() and fsck_object() to inspect only a prefix.
Use size_t for the size parameter in verify_fn,
struct odb_fsck_options.object_cb, and fsck_obj_buffer().
parse_object_buffer() and fsck_object() themselves still take an
"unsigned long"; until they are updated separately, they keep
inspecting only a prefix.
Triggering this requires processing objects of 4GiB or more on a
platform where "long" is 32 bits while size_t is 64, so no test is
added.
Signed-off-by: Elia Pinto <gitter.spiros@gmail.com>
---
builtin/fsck.c | 2 +-
odb.h | 2 +-
pack.h | 2 +-
3 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/builtin/fsck.c b/builtin/fsck.c
index c4558efcf1..5849194686 100644
--- a/builtin/fsck.c
+++ b/builtin/fsck.c
@@ -392,7 +392,7 @@ static void check_connectivity(struct repository *repo)
}
static int fsck_obj_buffer(const struct object_id *oid, enum object_type type,
- unsigned long size, void *buffer, int *eaten, void *cb_data)
+ size_t size, void *buffer, int *eaten, void *cb_data)
{
struct repository *repo = cb_data;
struct object *obj;
diff --git a/odb.h b/odb.h
index 857637f980..9d4ef41d9b 100644
--- a/odb.h
+++ b/odb.h
@@ -210,7 +210,7 @@ struct odb_fsck_options {
enum odb_fsck_flags flags;
int (*object_cb)(const struct object_id *oid, enum object_type type,
- unsigned long size, void *buffer, int *eaten, void *cb_data);
+ size_t size, void *buffer, int *eaten, void *cb_data);
void *object_payload;
};
diff --git a/pack.h b/pack.h
index 2f2ce97c11..acc72a9527 100644
--- a/pack.h
+++ b/pack.h
@@ -88,7 +88,7 @@ struct progress;
/* Note, the data argument could be NULL if object type is blob */
typedef int (*verify_fn)(const struct object_id *oid,
enum object_type type,
- unsigned long size,
+ size_t size,
void *buffer, int *eaten,
void *fn_data);
--
2.53.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* Re: [PATCH v2 4/4] pack-check: use size_t for the size passed to verify callbacks
2026-11-18 6:56 ` [PATCH v2 4/4] pack-check: use size_t for the size passed to verify callbacks Elia Pinto
@ 2026-11-18 13:34 ` Patrick Steinhardt
0 siblings, 0 replies; 14+ messages in thread
From: Patrick Steinhardt @ 2026-11-18 13:34 UTC (permalink / raw)
To: Elia Pinto; +Cc: git, Johannes Schindelin, Junio C Hamano
On Wed, Nov 18, 2026 at 07:56:38AM +0100, Elia Pinto wrote:
> verify_pack() in pack-check.c passes each object to a verify_fn callback
> (defined in pack.h) taking the object size as an "unsigned long", even
> though pack-check already handles it as a size_t. This signature is also
> replicated in struct odb_fsck_options (odb.h) and implemented by
> fsck_obj_buffer() in builtin/fsck.c.
>
> On platforms where "long" is 32 bits while size_t is 64, such as
> 64-bit Windows, running "git fsck" on packs with objects of 4GiB or
> more passes a truncated size to fsck_obj_buffer(), causing
> parse_object_buffer() and fsck_object() to inspect only a prefix.
The more interesting question to me is: if they only inspect a prefix,
do they actually notice that something is off and report the error? If
not that certainly sounds like a bug to me.
Patrick
^ permalink raw reply [flat|nested] 14+ messages in thread